 GFG App
Open App Browser
Continue

# Reverse Linked list by reducing segment size from both ends

Given a linked list of even length, where each element is an integer, the task is to reverse the list by performing the following steps repeatedly, after completing the below steps, return the new head of the list.

• Reverse the list and remove the first and last elements.
• Repeat step 1 until there are no more elements left.

Note: You are not allowed to use extra memory other than creating some new nodes required for the implementation.

Examples:

Input: 1 -> 5 -> 2 -> 7 -> 8 -> 3 -> NULL
Output: 3 -> 5 -> 7 -> 2 -> 8 -> 1 -> NULL
Explanation: The initial linked list is : 1 -> 5 -> 2 -> 7 -> 8 -> 3 -> NULL
Reverse the complete list: 3 -> 8 -> 7 -> 2 -> 5 -> 1 -> NULL
Reduce the segment by 1 from both ends and reverse the list: 3 -> 5 -> 2 -> 7 -> 8 -> 1 -> NULL
Reduce the segment by 1 from both ends and reverse the list: 3 -> 5 -> 7 -> 2 -> 8 -> 1 -> NULL

Input: 3 -> 4 -> 7 -> 8 -> NULL
Output: 8 -> 4 -> 7 -> 3 -> NULL

Approach: To solve the problem follow the below idea:

The idea is to traverse the half of the list and swap the values of nodes with the values of corresponding nodes on opposite sides of the list.

Below are the steps for the above approach:

• Initialize two pointers fast and slow to the head of the list, and a variable to store the length of the list length = 0.
• Traverse the list using the two-pointers. At each step, the fast pointer moves two steps forward and the slow pointer moves one step forward and increments the length variable by 2 at each step.
• Initialize a pointer node = head to traverse the list during the next phase.
• Iterate over half of the list (i.e., the first length/2 nodes) from i = 0 to t < length/2.
• For each iteration, check if the index of the current node being swapped is even.
• Initialize a temporary pointer temp = slow pointer as it is at mid+1 index and counts how many steps to move right to reach the right pointer of this segment,
count = length/2 – i – 1, Run a loop while count > 0, move temp pointer forward and decrement the count.
• Swap the values or nodes of the current node with the corresponding node on the right temp. If the index is odd, simply move to the next node.
• Continue this process until it has swapped all the nodes on one side of the list with the corresponding nodes on the opposite side of the list.
• Return the pointer to the new head of the reversed list.

Below is the code for the above approach:

## C++

 `// C++ code for the above approach:` `#include ` `using` `namespace` `std;`   `struct` `Node {` `    ``int` `val;` `    ``Node* next;` `    ``Node(``int` `val)` `        ``: val(val), next(nullptr)` `    ``{` `    ``}` `};`   `// Function to reverse the linked list` `Node* reverse(Node* head)` `{` `    ``Node* fast = head;` `    ``Node* slow = head;` `    ``int` `length = 0;`   `    ``// Find length of linked list` `    ``while` `(fast != nullptr && fast->next != nullptr) {` `        ``fast = fast->next->next;` `        ``slow = slow->next;` `        ``length += 2;` `    ``}`   `    ``Node* node = head;`   `    ``// Reversing the list` `    ``for` `(``int` `i = 0; i < length / 2; i++) {` `        ``if` `(i % 2 == 0) {`   `            ``// Assign the slow pointer as` `            ``// it is at mid + 1 index` `            ``Node* temp = slow;`   `            ``// How many steps to move right` `            ``// to reach right pointer of` `            ``// this segment` `            ``int` `count = length / 2 - i - 1;` `            ``while` `(count > 0) {` `                ``temp = temp->next;` `                ``count--;` `            ``}`   `            ``// Swap their values or you` `            ``// can also swap the nodes` `            ``int` `val = node->val;` `            ``node->val = temp->val;` `            ``temp->val = val;` `            ``node = node->next;` `        ``}` `        ``else` `{` `            ``node = node->next;` `        ``}` `    ``}`   `    ``return` `head;` `}`   `// Print the list` `void` `printList(Node* node)` `{` `    ``while` `(node != nullptr) {` `        ``cout << node->val << ``" "``;` `        ``node = node->next;` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``Node* head = ``new` `Node(1);` `    ``head->next = ``new` `Node(5);` `    ``head->next->next = ``new` `Node(2);` `    ``head->next->next->next = ``new` `Node(7);` `    ``head->next->next->next->next = ``new` `Node(8);` `    ``head->next->next->next->next->next = ``new` `Node(3);`   `    ``cout << ``"Given linked list"` `<< endl;` `    ``printList(head);`   `    ``head = reverse(head);`   `    ``cout << endl` `         ``<< ``"Reversed linked list"` `<< endl;` `    ``printList(head);`   `    ``return` `0;` `}`

## Java

 `/*package whatever // do not write package name here */`   `import` `java.io.*;`   `class` `GFG {` `    ``public` `static` `Node reverse(Node head)` `    ``{`   `        ``Node fast = head;` `        ``Node slow = head;` `        ``int` `length = ``0``;` `        ``// find length of linked list` `        ``while` `(fast != ``null` `&& fast.next != ``null``) {` `            ``fast = fast.next.next;` `            ``slow = slow.next;` `            ``length += ``2``;` `        ``}`   `        ``Node node = head;` `        ``// reversing the list` `        ``for` `(``int` `i = ``0``; i < length / ``2``; i++) {` `            ``if` `(i % ``2` `== ``0``) {` `                ``Node temp = slow; ``// assign the slow pointer as it is at mid + 1 index` `                ``int` `count = length / ``2` `- i - ``1``; ``// how many steps to move right to reach right pointer of this segment` `                ``while` `(count > ``0``) {` `                    ``temp = temp.next;` `                    ``count--;` `                ``}` `                ``int` `val = node.val; ``// swap their values or you can also swap the nodes` `                ``node.val = temp.val;` `                ``temp.val = val;` `                ``node = node.next;` `            ``}` `            ``else` `{` `                ``node = node.next;` `            ``}` `        ``}`   `        ``return` `head;` `    ``}` `    ``// print the list` `    ``public` `static` `void` `printList(Node node)` `    ``{` `        ``while` `(node != ``null``) {` `            ``System.out.print(node.val + ``" "``);` `            ``node = node.next;` `        ``}` `    ``}` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``Node head = ``new` `Node(``1``);` `        ``head.next = ``new` `Node(``5``);` `        ``head.next.next = ``new` `Node(``2``);` `        ``head.next.next.next = ``new` `Node(``7``);` `        ``head.next.next.next.next = ``new` `Node(``8``);` `        ``head.next.next.next.next.next = ``new` `Node(``3``);`   `        ``System.out.println(``"Given linked list"``);` `        ``printList(head);`   `        ``head = reverse(head);`   `        ``System.out.println(``""``);` `        ``System.out.println(``"Reversed linked list "``);` `        ``printList(head);` `    ``}` `}` `class` `Node {` `    ``int` `val;` `    ``Node next;`   `    ``Node(``int` `val)` `    ``{` `        ``this``.val = val;` `        ``next = ``null``;` `    ``}` `}`   `// This code has been contributed by vishalkumarsahu04`

## Python3

 `class` `Node:` `    ``def` `__init__(``self``, val):` `        ``self``.val ``=` `val` `        ``self``.``next` `=` `None`   `def` `reverse(head):` `    ``fast ``=` `head` `    ``slow ``=` `head` `    ``length ``=` `0`   `    ``# find length of linked list` `    ``while` `fast ``and` `fast.``next``:` `        ``fast ``=` `fast.``next``.``next` `        ``slow ``=` `slow.``next` `        ``length ``+``=` `2`   `    ``node ``=` `head` `    ``# reversing the list` `    ``for` `i ``in` `range``(length ``/``/` `2``):` `        ``if` `i ``%` `2` `=``=` `0``:` `            ``temp ``=` `slow  ``# assign the slow pointer as it is at mid + 1 index` `            ``count ``=` `length ``/``/` `2` `-` `i ``-` `1`  `# how many steps to move right to reach right pointer of this segment` `            ``while` `count > ``0``:` `                ``temp ``=` `temp.``next` `                ``count ``-``=` `1` `            ``val ``=` `node.val  ``# swap their values or you can also swap the nodes` `            ``node.val ``=` `temp.val` `            ``temp.val ``=` `val` `            ``node ``=` `node.``next` `        ``else``:` `            ``node ``=` `node.``next`   `    ``return` `head`   `# print the list` `def` `printList(node):` `    ``while` `node:` `        ``print``(node.val, end``=``" "``)` `        ``node ``=` `node.``next`   `# test the implementation` `head ``=` `Node(``1``)` `head.``next` `=` `Node(``5``)` `head.``next``.``next` `=` `Node(``2``)` `head.``next``.``next``.``next` `=` `Node(``7``)` `head.``next``.``next``.``next``.``next` `=` `Node(``8``)` `head.``next``.``next``.``next``.``next``.``next` `=` `Node(``3``)`   `print``(``"Given linked list"``)` `printList(head)`   `head ``=` `reverse(head)`   `print``(``"\nReversed linked list "``)` `printList(head)`

## C#

 `// C# code for the above approach:`   `using` `System;`   `public` `class` `Node {` `    ``public` `int` `val;` `    ``public` `Node next;` `    ``public` `Node(``int` `val) {` `        ``this``.val = val;` `        ``this``.next = ``null``;` `    ``}` `}`   `public` `class` `GFG {` `      ``// Function to reverse the linked list` `    ``public` `static` `Node Reverse(Node head) {` `        ``Node fast = head;` `        ``Node slow = head;` `        ``int` `length = 0;`   `        ``// Find length of linked list` `        ``while` `(fast != ``null` `&& fast.next != ``null``) {` `            ``fast = fast.next.next;` `            ``slow = slow.next;` `            ``length += 2;` `        ``}`   `        ``Node node = head;`   `        ``// Reversing the list` `        ``for` `(``int` `i = 0; i < length / 2; i++) {` `            ``if` `(i % 2 == 0) {`   `                ``// Assign the slow pointer as` `                ``// it is at mid + 1 index` `                ``Node temp = slow;`   `                ``// How many steps to move right` `                ``// to reach right pointer of` `                ``// this segment` `                ``int` `count = length / 2 - i - 1;` `                ``while` `(count > 0) {` `                    ``temp = temp.next;` `                    ``count--;` `                ``}`   `                ``// Swap their values or you` `                ``// can also swap the nodes` `                ``int` `val = node.val;` `                ``node.val = temp.val;` `                ``temp.val = val;` `                ``node = node.next;` `            ``}` `            ``else` `{` `                ``node = node.next;` `            ``}` `        ``}`   `        ``return` `head;` `    ``}`   `    ``public` `static` `void` `PrintList(Node node) {` `        ``while` `(node != ``null``) {` `            ``Console.Write(node.val + ``" "``);` `            ``node = node.next;` `        ``}` `    ``}` `    `  `      ``// Driver code` `    ``public` `static` `void` `Main(``string``[] args) {` `        ``Node head = ``new` `Node(1);` `        ``head.next = ``new` `Node(5);` `        ``head.next.next = ``new` `Node(2);` `        ``head.next.next.next = ``new` `Node(7);` `        ``head.next.next.next.next = ``new` `Node(8);` `        ``head.next.next.next.next.next = ``new` `Node(3);` `        `  `          ``// Print the list` `        ``Console.WriteLine(``"Given linked list"``);` `        ``PrintList(head);`   `          ``// Function Call` `        ``head = Reverse(head);`   `          ``// Print the list` `        ``Console.WriteLine(``"\nReversed linked list"``);` `        ``PrintList(head);` `    ``}` `}`

## Javascript

 `// JavaScript code for the approach`   `class Node {` `    ``constructor(val) {` `        ``this``.val = val;` `        ``this``.next = ``null``;` `    ``}` `}`   `// Function to reverse the linked list` `function` `reverse(head) {` `    ``let fast = head;` `    ``let slow = head;` `    ``let length = 0;`   `    ``// Find length of linked list` `    ``while` `(fast != ``null` `&& fast.next != ``null``) {` `        ``fast = fast.next.next;` `        ``slow = slow.next;` `        ``length += 2;` `    ``}`   `    ``let node = head;`   `    ``// Reversing the list` `    ``for` `(let i = 0; i < length / 2; i++) {` `        ``if` `(i % 2 == 0) {`   `            ``// Assign the slow pointer as` `            ``// it is at mid + 1 index` `            ``let temp = slow;`   `            ``// How many steps to move right` `            ``// to reach right pointer of` `            ``// this segment` `            ``let count = length / 2 - i - 1;` `            ``while` `(count > 0) {` `                ``temp = temp.next;` `                ``count--;` `            ``}`   `            ``// Swap their values or you` `            ``// can also swap the nodes` `            ``let val = node.val;` `            ``node.val = temp.val;` `            ``temp.val = val;` `            ``node = node.next;` `        ``}` `        ``else` `{` `            ``node = node.next;` `        ``}` `    ``}`   `    ``return` `head;` `}`   `// Print the list` `function` `printList(node) {` `    ``let res = ``''``;` `    ``while` `(node !== ``null``) {` `      ``res += node.val + ``' '``;` `      ``node = node.next;` `    ``}` `    ``return` `res.trim();` `}`   `// Driver code` `let head = ``new` `Node(1);` `head.next = ``new` `Node(5);` `head.next.next = ``new` `Node(2);` `head.next.next.next = ``new` `Node(7);` `head.next.next.next.next = ``new` `Node(8);` `head.next.next.next.next.next = ``new` `Node(3);`   `console.log(``"Given linked list"``);` `console.log(printList(head));`   `head = reverse(head);`   `console.log(``"Reversed linked list"``);` `console.log(printList(head));`

Output

```Given linked list
1 5 2 7 8 3