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

Last Updated : 11 Sep, 2023

Given pointer to the head node of a linked list, the task is to reverse the linked list.

Examples:

Input : Head of following linked list           1->2->3->4->NULL  Output : Linked list should be changed to,         4->3->2->1->NULL    Input : Head of following linked list           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 <bits/stdc++.h> 
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

   <script> 
// javascript program to reverse a linked  
// list using two pointers. 
  
    // Link list node 
class Node  
{ 
    constructor() 
    { 
        this.data = 0; 
        this.next = null; 
    } 
} 
  
    var head_ref = null; 
  
    // Function to reverse the linked 
    // list using 2 pointers 
    function reverse() 
    { 
        var prev = null; 
        var 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 
            var next = current.next; 
            current.next = prev; 
            prev = current; 
            current = next; 
        } 
        head_ref = prev; 
    } 
  
    // Function to push a node 
    function push(new_data) 
    { 
  
        // Allocate node 
        var 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 
    function printList() 
    { 
        var temp = head_ref; 
        while (temp != null) 
        { 
            document.write(temp.data + " "); 
            temp = temp.next; 
        } 
    } 
  
    // Driver code     
        push(20); 
        push(4); 
        push(15); 
        push(85); 
  
        document.write("Given linked list<br/>"); 
        printList(); 
        reverse(); 
        document.write("<br/>Reversed Linked list <br/>"); 
        printList(); 
  
// This code is contributed by todaysgaurav.  
</script>
 
  

Output:

Given linked list  85  15  4  20    Reversed Linked list   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 <bits/stdc++.h> 
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

   <script> 
// javascript program to reverse a linked  
// list using two pointers. 
  
    // Link list node 
class Node  
{ 
    constructor() 
    { 
        this.data = 0; 
        this.next = null; 
    } 
} 
  
    var head_ref = null; 
  
    // Function to reverse the linked 
    // list using 2 pointers 
    function reverse() 
    { 
        var current = head_ref; 
        var next; 
        while (current.next != null) 
        { 
            next = current.next; 
            current.next = next.next; 
            next.next = head_ref; 
            head_ref = next; 
        } 
    } 
  
    // Function to push a node 
    function push(new_data) 
    { 
  
        // Allocate node 
        var 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 
    function printList() 
    { 
        var temp = head_ref; 
        while (temp != null) 
        { 
            document.write(temp.data + " "); 
            temp = temp.next; 
        } 
    } 
  
    // Driver code     
        push(20); 
        push(4); 
        push(15); 
        push(85); 
  
        document.write("Given linked list<br/>"); 
        printList(); 
        reverse(); 
        document.write("<br/>Reversed Linked list <br/>"); 
        printList(); 
  
// This code is contributed by Abhijeet Kumar(abhijeet19403)  
</script>
 
  

Output:

Given linked list  85  15  4  20    Reversed Linked list   20  4  15  85

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

Thanks to Abhay Yadav for suggesting this approach.

Print alternate nodes of a linked list using recursion

Shashank Mishra ( Gullu )

Improve

Article Tags :

Practice Tags :

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

C++

Java

Python3

C#

Javascript

C++

Java

Python3

C#

Javascript

Similar Reads