# Iteratively Reverse a linked list using only 2 pointers (An Interesting Method)

Last Updated : 11 Sep, 2023

Examples:

```Input : Head of following linked list
1->2->3->4->NULL
Output : Linked list should be changed to,
4->3->2->1->NULL

1->2->3->4->5->NULL
Output : Linked list should be changed to,
5->4->3->2->1->NULL```

We have seen how to reverse a linked list in article Reverse a linked list. In iterative method we had used 3 pointers prev, cur and next. Below is an interesting approach that uses only two pointers. The idea is to use XOR to swap pointers.

## C++

 `// C++ program to reverse a linked list using two pointers. ` `#include ` `using` `namespace` `std; ` `typedef` `uintptr_t` `ut; ` ` `  `/* Link list node */` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node* next; ` `}; ` ` `  `/* Function to reverse the linked list using 2 pointers */` `void` `reverse(``struct` `Node** head_ref) ` `{ ` `    ``struct` `Node* prev = NULL; ` `    ``struct` `Node* current = *head_ref; ` ` `  `    ``// at last prev points to new head ` `    ``while` `(current != NULL) { ` `        ``// This expression evaluates from left to right ` `        ``// current->next = prev, changes the link from ` `        ``// next to prev node ` `        ``// prev = current, moves prev to current node for ` `        ``// next reversal of node ` `        ``// This example of list will clear it more ` `        ``// 1->2->3->4 initially prev = 1, current = 2 Final ` `        ``// expression will be current = 1^2^3^2^1, as we ` `        ``// know that bitwise XOR of two same numbers will ` `        ``// always be 0 i.e; 1^1 = 2^2 = 0 After the ` `        ``// evaluation of expression current = 3 that means ` `        ``// it has been moved by one node from its previous ` `        ``// position ` `        ``current ` `            ``= (``struct` `Node*)((ut)prev ^ (ut)current ` `                             ``^ (ut)(current->next) ` `                             ``^ (ut)(current->next = prev) ` `                             ``^ (ut)(prev = current)); ` `    ``} ` ` `  `    ``*head_ref = prev; ` `} ` ` `  `/* Function to push a node */` `void` `push(``struct` `Node** head_ref, ``int` `new_data) ` `{ ` `    ``/* allocate node */` `    ``struct` `Node* new_node ` `        ``= (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node)); ` ` `  `    ``/* put in the data  */` `    ``new_node->data = new_data; ` ` `  `    ``/* link the old list of the new node */` `    ``new_node->next = (*head_ref); ` ` `  `    ``/* move the head to point to the new node */` `    ``(*head_ref) = new_node; ` `} ` ` `  `/* Function to print linked list */` `void` `printList(``struct` `Node* head) ` `{ ` `    ``struct` `Node* temp = head; ` `    ``while` `(temp != NULL) { ` `        ``printf``(``"%d  "``, temp->data); ` `        ``temp = temp->next; ` `    ``} ` `} ` ` `  `/* Driver program to test above function*/` `int` `main() ` `{ ` `    ``/* Start with the empty list */` `    ``struct` `Node* head = NULL; ` ` `  `    ``push(&head, 20); ` `    ``push(&head, 4); ` `    ``push(&head, 15); ` `    ``push(&head, 85); ` ` `  `    ``printf``(``"Given linked list\n"``); ` `    ``printList(head); ` `    ``reverse(&head); ` `    ``printf``(``"\nReversed Linked list \n"``); ` `    ``printList(head); ` `    ``return` `0; ` `}`

## Java

 `// Java program to reverse a linked ` `// list using two pointers. ` `import` `java.util.*; ` ` `  `class` `Main { ` ` `  `    ``// Link list node ` `    ``static` `class` `Node { ` `        ``int` `data; ` `        ``Node next; ` `    ``}; ` ` `  `    ``static` `Node head_ref = ``null``; ` ` `  `    ``// Function to reverse the linked ` `    ``// list using 2 pointers ` `    ``static` `void` `reverse() ` `    ``{ ` `        ``Node prev = ``null``; ` `        ``Node current = head_ref; ` ` `  `        ``// At last prev points to new head ` `        ``while` `(current != ``null``) { ` ` `  `            ``// This expression evaluates from left to right ` `            ``// current.next = prev, changes the link from ` `            ``// next to prev node ` `            ``// prev = current, moves prev to current node ` `            ``// for next reversal of node This example of ` `            ``// list will clear it more 1.2.3.4 initially ` `            ``// prev = 1, current = 2 Final expression will ` `            ``// be current = 1^2^3^2^1, as we know that ` `            ``// bitwise XOR of two same numbers will always ` `            ``// be 0 i.e; 1^1 = 2^2 = 0 After the evaluation ` `            ``// of expression current = 3 that means it has ` `            ``// been moved by one node from its previous ` `            ``// position ` `            ``Node next = current.next; ` `            ``current.next = prev; ` `            ``prev = current; ` `            ``current = next; ` `        ``} ` `        ``head_ref = prev; ` `    ``} ` ` `  `    ``// Function to push a node ` `    ``static` `void` `push(``int` `new_data) ` `    ``{ ` ` `  `        ``// Allocate node ` `        ``Node new_node = ``new` `Node(); ` ` `  `        ``// Put in the data ` `        ``new_node.data = new_data; ` ` `  `        ``// Link the old list of the new node ` `        ``new_node.next = (head_ref); ` ` `  `        ``// Move the head to point to the new node ` `        ``(head_ref) = new_node; ` `    ``} ` ` `  `    ``// Function to print linked list ` `    ``static` `void` `printList() ` `    ``{ ` `        ``Node temp = head_ref; ` `        ``while` `(temp != ``null``) { ` `            ``System.out.print(temp.data + ``" "``); ` `            ``temp = temp.next; ` `        ``} ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``push(``20``); ` `        ``push(``4``); ` `        ``push(``15``); ` `        ``push(``85``); ` ` `  `        ``System.out.print(``"Given linked list\n"``); ` `        ``printList(); ` `        ``reverse(); ` `        ``System.out.print(``"\nReversed Linked list \n"``); ` `        ``printList(); ` `    ``} ` `} ` ` `  `// This code is contributed by rutvik_56`

## Python3

 `# Iteratively Reverse a linked list using only 2 pointers (An Interesting Method) ` `# Python program to reverse a linked list ` `# Link list node ` `# node class ` ` `  ` `  `class` `node: ` ` `  `    ``# Constructor to initialize the node object ` `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data ` `        ``self``.``next` `=` `None` ` `  ` `  `class` `LinkedList: ` ` `  `    ``# Function to initialize head ` `    ``def` `__init__(``self``): ` `        ``self``.head ``=` `None` ` `  `    ``# Function to reverse the linked list ` `    ``def` `reverse(``self``): ` `        ``prev ``=` `None` `        ``current ``=` `self``.head ` `    ``# Described here https://www.geeksforgeeks.org/ ` `    ``# how-to-swap-two-variables-in-one-line / ` `        ``while``(current ``is` `not` `None``): ` `            ``# This expression evaluates from left to right ` `            ``# current->next = prev, changes the link from ` `            ``# next to prev node ` `            ``# prev = current, moves prev to current node for ` `            ``# next reversal of node ` `            ``# This example of list will clear it more 1->2 ` `            ``# initially prev = 1, current = 2 ` `            ``# Final expression will be current = 1, prev = 2 ` `            ``next``, current.``next` `=` `current.``next``, prev ` `            ``prev, current ``=` `current, ``next` `        ``self``.head ``=` `prev ` ` `  `    ``# Function to push a new node ` `    ``def` `push(``self``, new_data): ` `        ``# allocate node and put in the data ` `        ``new_node ``=` `node(new_data) ` `        ``# link the old list of the new node ` `        ``new_node.``next` `=` `self``.head ` `        ``# move the head to point to the new node ` `        ``self``.head ``=` `new_node ` ` `  `    ``# Function to print the linked list ` `    ``def` `printList(``self``): ` `        ``temp ``=` `self``.head ` `        ``while``(temp): ` `            ``print``(temp.data, end``=``" "``) ` `            ``temp ``=` `temp.``next` ` `  ` `  `# Driver program to test above functions ` `llist ``=` `LinkedList() ` `llist.push(``20``) ` `llist.push(``4``) ` `llist.push(``15``) ` `llist.push(``85``) ` ` `  `print``(``"Given Linked List"``) ` `llist.printList() ` `llist.reverse() ` `print``(``"\nReversed Linked List"``) ` `llist.printList() ` ` `  `# This code is contributed by Afzal Ansari `

## C#

 `// C# program to reverse a linked ` `// list using two pointers. ` `using` `System; ` `using` `System.Collections; ` `using` `System.Collections.Generic; ` `class` `GFG { ` ` `  `    ``// Link list node ` `    ``class` `Node { ` `        ``public` `int` `data; ` `        ``public` `Node next; ` `    ``}; ` ` `  `    ``static` `Node head_ref = ``null``; ` ` `  `    ``// Function to reverse the linked ` `    ``// list using 2 pointers ` `    ``static` `void` `reverse() ` `    ``{ ` `        ``Node prev = ``null``; ` `        ``Node current = head_ref; ` ` `  `        ``// At last prev points to new head ` `        ``while` `(current != ``null``) { ` ` `  `            ``// This expression evaluates from left to right ` `            ``// current.next = prev, changes the link from ` `            ``// next to prev node ` `            ``// prev = current, moves prev to current node ` `            ``// for next reversal of node This example of ` `            ``// list will clear it more 1.2.3.4 initially ` `            ``// prev = 1, current = 2 Final expression will ` `            ``// be current = 1^2^3^2^1, as we know that ` `            ``// bitwise XOR of two same numbers will always ` `            ``// be 0 i.e; 1^1 = 2^2 = 0 After the evaluation ` `            ``// of expression current = 3 that means it has ` `            ``// been moved by one node from its previous ` `            ``// position ` `            ``Node next = current.next; ` `            ``current.next = prev; ` `            ``prev = current; ` `            ``current = next; ` `        ``} ` `        ``head_ref = prev; ` `    ``} ` ` `  `    ``// Function to push a node ` `    ``static` `void` `push(``int` `new_data) ` `    ``{ ` ` `  `        ``// Allocate node ` `        ``Node new_node = ``new` `Node(); ` ` `  `        ``// Put in the data ` `        ``new_node.data = new_data; ` ` `  `        ``// Link the old list of the new node ` `        ``new_node.next = (head_ref); ` ` `  `        ``// Move the head to point to the new node ` `        ``(head_ref) = new_node; ` `    ``} ` ` `  `    ``// Function to print linked list ` `    ``static` `void` `printList() ` `    ``{ ` `        ``Node temp = head_ref; ` `        ``while` `(temp != ``null``) { ` `            ``Console.Write(temp.data + ``" "``); ` `            ``temp = temp.next; ` `        ``} ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(``string``[] args) ` `    ``{ ` `        ``push(20); ` `        ``push(4); ` `        ``push(15); ` `        ``push(85); ` ` `  `        ``Console.Write(``"Given linked list\n"``); ` `        ``printList(); ` `        ``reverse(); ` `        ``Console.Write(``"\nReversed Linked list \n"``); ` `        ``printList(); ` `    ``} ` `} ` ` `  `// This code is contributed by pratham76`

## Javascript

 ``

Output:

```Given linked list
85  15  4  20
20  4  15  85```

Time Complexity: O(n)
Auxiliary Space: O(1) since using space for prev and next

Alternate Solution :

## C++

 `// C++ program to reverse a linked list using two pointers. ` `#include ` `using` `namespace` `std; ` `typedef` `uintptr_t` `ut; ` ` `  `/* Link list node */` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node* next; ` `}; ` ` `  `/* Function to reverse the linked list using 2 pointers */` `void` `reverse(``struct` `Node** head_ref) ` `{ ` `    ``struct` `Node* current = *head_ref; ` `    ``struct` `Node* next; ` `    ``while` `(current->next != NULL) { ` `        ``next = current->next; ` `        ``current->next = next->next; ` `        ``next->next = (*head_ref); ` `        ``*head_ref = next; ` `    ``} ` `} ` ` `  `/* Function to push a node */` `void` `push(``struct` `Node** head_ref, ``int` `new_data) ` `{ ` `    ``struct` `Node* new_node = ``new` `Node; ` `    ``new_node->data = new_data; ` `    ``new_node->next = (*head_ref); ` `    ``(*head_ref) = new_node; ` `} ` ` `  `/* Function to print linked list */` `void` `printList(``struct` `Node* head) ` `{ ` `    ``struct` `Node* temp = head; ` `    ``while` `(temp != NULL) { ` `        ``printf``(``"%d  "``, temp->data); ` `        ``temp = temp->next; ` `    ``} ` `} ` ` `  `/* Driver program to test above function*/` `int` `main() ` `{ ` `    ``/* Start with the empty list */` `    ``struct` `Node* head = NULL; ` ` `  `    ``push(&head, 20); ` `    ``push(&head, 4); ` `    ``push(&head, 15); ` `    ``push(&head, 85); ` ` `  `    ``printf``(``"Given linked list\n"``); ` `    ``printList(head); ` `    ``reverse(&head); ` `    ``printf``(``"\nReversed Linked list \n"``); ` `    ``printList(head); ` `    ``return` `0; ` `} `

## Java

 `// Java program to reverse a linked ` `// list using two pointers. ` `import` `java.util.*; ` ` `  `class` `Main { ` ` `  `    ``// Link list node ` `    ``static` `class` `Node { ` `        ``int` `data; ` `        ``Node next; ` `    ``}; ` ` `  `    ``static` `Node head_ref = ``null``; ` ` `  `    ``// Function to reverse the linked ` `    ``// list using 2 pointers ` `    ``static` `void` `reverse() ` `    ``{ ` `        ``Node next; ` `        ``Node curr = head_ref; ` `        ``while` `(curr.next != ``null``) { ` `            ``next = curr.next; ` `            ``curr.next = next.next; ` `            ``next.next = head_ref; ` `            ``head_ref = next; ` `        ``} ` `    ``} ` ` `  `    ``// Function to push a node ` `    ``static` `void` `push(``int` `new_data) ` `    ``{ ` ` `  `        ``// Allocate node ` `        ``Node new_node = ``new` `Node(); ` ` `  `        ``// Put in the data ` `        ``new_node.data = new_data; ` ` `  `        ``// Link the old list of the new node ` `        ``new_node.next = (head_ref); ` ` `  `        ``// Move the head to point to the new node ` `        ``(head_ref) = new_node; ` `    ``} ` ` `  `    ``// Function to print linked list ` `    ``static` `void` `printList() ` `    ``{ ` `        ``Node temp = head_ref; ` `        ``while` `(temp != ``null``) { ` `            ``System.out.print(temp.data + ``" "``); ` `            ``temp = temp.next; ` `        ``} ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``push(``20``); ` `        ``push(``4``); ` `        ``push(``15``); ` `        ``push(``85``); ` ` `  `        ``System.out.print(``"Given linked list\n"``); ` `        ``printList(); ` `        ``reverse(); ` `        ``System.out.print(``"\nReversed Linked list \n"``); ` `        ``printList(); ` `    ``} ` `} ` ` `  `// This code is contributed by Abhijeet Kumar(abhijeet19403)`

## Python3

 `# Python3 program to reverse a linked list using two pointers. ` ` `  `# A linked list node  ` `class` `Node : ` `    ``def` `__init__(``self``): ` `        ``self``.data ``=` `0` `        ``self``.``next` `=` `None` ` `  `# Function to reverse the linked list using 2 pointers  ` `def` `reverse(head_ref): ` ` `  `    ``current ``=` `head_ref ` `    ``next``=` `None` `    ``while` `(current.``next` `!``=` `None``) : ` `        ``next` `=` `current.``next` `        ``current.``next` `=` `next``.``next` `        ``next``.``next` `=` `(head_ref) ` `        ``head_ref ``=` `next` `     `  `    ``return` `head_ref ` ` `  `# Function to push a node  ` `def` `push( head_ref, new_data): ` ` `  `    ``new_node ``=` `Node() ` `    ``new_node.data ``=` `new_data ` `    ``new_node.``next` `=` `(head_ref) ` `    ``(head_ref) ``=` `new_node ` `    ``return` `head_ref ` ` `  `# Function to print linked list  ` `def` `printList( head): ` ` `  `    ``temp ``=` `head ` `    ``while` `(temp !``=` `None``) : ` `        ``print``( temp.data, end``=``" "``) ` `        ``temp ``=` `temp.``next` `     `  `# Driver code ` ` `  `# Start with the empty list  ` `head ``=` `None` ` `  `head ``=` `push(head, ``20``) ` `head ``=` `push(head, ``4``) ` `head ``=` `push(head, ``15``) ` `head ``=` `push(head, ``85``) ` ` `  `print``(``"Given linked list"``) ` `printList(head) ` `head ``=` `reverse(head) ` `print``(``"\nReversed Linked list "``) ` `printList(head) ` ` `  `# This code is contributed by Arnab Kundu `

## C#

 `// C# program to reverse a linked ` `// list using two pointers. ` `using` `System; ` `using` `System.Collections; ` `using` `System.Collections.Generic; ` `class` `GFG { ` ` `  `    ``// Link list node ` `    ``class` `Node { ` `        ``public` `int` `data; ` `        ``public` `Node next; ` `    ``}; ` ` `  `    ``static` `Node head_ref = ``null``; ` ` `  `    ``// Function to reverse the linked ` `    ``// list using 2 pointers ` `    ``static` `void` `reverse() ` `    ``{ ` `        ``Node current = head_ref; ` `        ``Node next; ` `        ``while` `(current.next != ``null``) { ` `            ``next = current.next; ` `            ``current.next = next.next; ` `            ``next.next = head_ref; ` `            ``head_ref = next; ` `        ``} ` `    ``} ` ` `  `    ``// Function to push a node ` `    ``static` `void` `push(``int` `new_data) ` `    ``{ ` ` `  `        ``// Allocate node ` `        ``Node new_node = ``new` `Node(); ` ` `  `        ``// Put in the data ` `        ``new_node.data = new_data; ` ` `  `        ``// Link the old list of the new node ` `        ``new_node.next = (head_ref); ` ` `  `        ``// Move the head to point to the new node ` `        ``(head_ref) = new_node; ` `    ``} ` ` `  `    ``// Function to print linked list ` `    ``static` `void` `printList() ` `    ``{ ` `        ``Node temp = head_ref; ` `        ``while` `(temp != ``null``) { ` `            ``Console.Write(temp.data + ``" "``); ` `            ``temp = temp.next; ` `        ``} ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(``string``[] args) ` `    ``{ ` `        ``push(20); ` `        ``push(4); ` `        ``push(15); ` `        ``push(85); ` ` `  `        ``Console.Write(``"Given linked list\n"``); ` `        ``printList(); ` `        ``reverse(); ` `        ``Console.Write(``"\nReversed Linked list \n"``); ` `        ``printList(); ` `    ``} ` `} ` ` `  `// This code is contributed by Abhijeet Kumar(abhijeet19403)`

## Javascript

 ``

Output:

```Given linked list
85  15  4  20
20  4  15  85```

Time Complexity : O(n)
Auxiliary Space: O(1)

Thanks to Abhay Yadav for suggesting this approach.