Reverse a linked list
Given pointer to the head node of a linked list, the task is to reverse the linked list. We need to reverse the list by changing the links between nodes.
Examples:
Input: Head of following linked list
1->2->3->4->NULL
Output: Linked list should be changed to,
4->3->2->1->NULLInput: Head of following linked list
1->2->3->4->5->NULL
Output: Linked list should be changed to,
5->4->3->2->1->NULLInput: NULL
Output: NULLInput: 1->NULL
Output: 1->NULL
Iterative Method
- Initialize three pointers prev as NULL, curr as head and next as NULL.
- Iterate through the linked list. In loop, do following.
// Before changing next of current,
// store next node
next = curr->next
// Now change next of current
// This is where actual reversing happens
curr->next = prev
// Move prev and curr one step forward
prev = curr
curr = next
Below is the implementation of the above approach:
C++
// Iterative C++ program to reverse// a linked list#include <iostream>using namespace std;/* Link list node */struct Node { int data; struct Node* next; Node(int data) { this->data = data; next = NULL; }};struct LinkedList { Node* head; LinkedList() { head = NULL; } /* Function to reverse the linked list */ void reverse() { // Initialize current, previous and // next pointers Node* current = head; Node *prev = NULL, *next = NULL; while (current != NULL) { // Store next next = current->next; // Reverse current node's pointer current->next = prev; // Move pointers one position ahead. prev = current; current = next; } head = prev; } /* Function to print linked list */ void print() { struct Node* temp = head; while (temp != NULL) { cout << temp->data << " "; temp = temp->next; } } void push(int data) { Node* temp = new Node(data); temp->next = head; head = temp; }};/* Driver code*/int main(){ /* Start with the empty list */ LinkedList ll; ll.push(20); ll.push(4); ll.push(15); ll.push(85); cout << "Given linked list\n"; ll.print(); ll.reverse(); cout << "\nReversed Linked list \n"; ll.print(); return 0;} |
C
// Iterative C program to reverse a linked list#include <stdio.h>#include <stdlib.h>/* Link list node */struct Node { int data; struct Node* next;};/* Function to reverse the linked list */static void reverse(struct Node** head_ref){ struct Node* prev = NULL; struct Node* current = *head_ref; struct Node* next = NULL; while (current != NULL) { // Store next next = current->next; // Reverse current node's pointer current->next = prev; // Move pointers one position ahead. prev = current; current = next; } *head_ref = prev;}/* Function to push a node */void push(struct Node** head_ref, int new_data){ struct Node* new_node = (struct Node*)malloc(sizeof(struct 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 code*/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); getchar();} |
Java
// Java program for reversing the linked listclass LinkedList { static Node head; static class Node { int data; Node next; Node(int d) { data = d; next = null; } } /* Function to reverse the linked list */ Node reverse(Node node) { Node prev = null; Node current = node; Node next = null; while (current != null) { next = current.next; current.next = prev; prev = current; current = next; } node = prev; return node; } // prints content of double linked list void printList(Node node) { while (node != null) { System.out.print(node.data + " "); node = node.next; } } // Driver Code public static void main(String[] args) { LinkedList list = new LinkedList(); list.head = new Node(85); list.head.next = new Node(15); list.head.next.next = new Node(4); list.head.next.next.next = new Node(20); System.out.println("Given Linked list"); list.printList(head); head = list.reverse(head); System.out.println(""); System.out.println("Reversed linked list "); list.printList(head); }}// This code has been contributed by Mayank Jaiswal |
Python
# Python program to reverse a linked list# Time Complexity : O(n)# Space Complexity : O(1)# Node classclass Node: # Constructor to initialize the node object def __init__(self, data): self.data = data self.next = Noneclass 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 while(current is not None): next = current.next current.next = prev prev = current current = next self.head = prev # Function to insert a new node at the beginning def push(self, new_data): new_node = Node(new_data) new_node.next = self.head self.head = new_node # Utility function to print the linked LinkedList def printList(self): temp = self.head while(temp): print temp.data, temp = temp.next# Driver codellist = 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 Nikhil Kumar Singh(nickzuck_007) |
C#
// C# program for reversing the linked listusing System;class GFG { // Driver Code static void Main(string[] args) { LinkedList list = new LinkedList(); list.AddNode(new LinkedList.Node(85)); list.AddNode(new LinkedList.Node(15)); list.AddNode(new LinkedList.Node(4)); list.AddNode(new LinkedList.Node(20)); // List before reversal Console.WriteLine("Given linked list:"); list.PrintList(); // Reverse the list list.ReverseList(); // List after reversal Console.WriteLine("Reversed linked list:"); list.PrintList(); }}class LinkedList { Node head; public class Node { public int data; public Node next; public Node(int d) { data = d; next = null; } } // function to add a new node at // the end of the list public void AddNode(Node node) { if (head == null) head = node; else { Node temp = head; while (temp.next != null) { temp = temp.next; } temp.next = node; } } // function to reverse the list public void ReverseList() { Node prev = null, current = head, next = null; while (current != null) { next = current.next; current.next = prev; prev = current; current = next; } head = prev; } // function to print the list data public void PrintList() { Node current = head; while (current != null) { Console.Write(current.data + " "); current = current.next; } Console.WriteLine(); }}// This code is contributed by Mayank Sharma |
Output:
Given linked list 85 15 4 20 Reversed Linked list 20 4 15 85
Time Complexity: O(n)
Space Complexity: O(1)
Recursive Method:
1) Divide the list in two parts - first node and
rest of the linked list.
2) Call reverse for the rest of the linked list.
3) Link rest to first.
4) Fix head pointer
C++
// Recursive C++ program to reverse// a linked list#include <iostream>using namespace std;/* Link list node */struct Node { int data; struct Node* next; Node(int data) { this->data = data; next = NULL; }};struct LinkedList { Node* head; LinkedList() { head = NULL; } Node* reverse(Node* head) { if (head == NULL || head->next == NULL) return head; /* reverse the rest list and put the first element at the end */ Node* rest = reverse(head->next); head->next->next = head; /* tricky step -- see the diagram */ head->next = NULL; /* fix the head pointer */ return rest; } /* Function to print linked list */ void print() { struct Node* temp = head; while (temp != NULL) { cout << temp->data << " "; temp = temp->next; } } void push(int data) { Node* temp = new Node(data); temp->next = head; head = temp; }};/* Driver program to test above function*/int main(){ /* Start with the empty list */ LinkedList ll; ll.push(20); ll.push(4); ll.push(15); ll.push(85); cout << "Given linked list\n"; ll.print(); ll.head = ll.reverse(ll.head); cout << "\nReversed Linked list \n"; ll.print(); return 0;} |
Java
// Recursive Java program to reverse// a linked listclass recursion { static Node head; // head of list static class Node { int data; Node next; Node(int d) { data = d; next = null; } } static Node reverse(Node head) { if (head == null || head.next == null) return head; /* reverse the rest list and put the first element at the end */ Node rest = reverse(head.next); head.next.next = head; /* tricky step -- see the diagram */ head.next = null; /* fix the head pointer */ return rest; } /* Function to print linked list */ static void print() { Node temp = head; while (temp != null) { System.out.print(temp.data + " "); temp = temp.next; } System.out.println(); } static void push(int data) { Node temp = new Node(data); temp.next = head; head = temp; } /* Driver program to test above function*/public static void main(String args[]){ /* Start with the empty list */ push(20); push(4); push(15); push(85); System.out.println("Given linked list"); print(); head = reverse(head); System.out.println("Reversed Linked list"); print();}}// This code is contributed by Prakhar Agarwal |
Python3
"""Python3 program to reverse linked listusing recursive method"""# Linked List Nodeclass Node: def __init__(self, data): self.data = data self.next = None# Create and Handle list operationsclass LinkedList: def __init__(self): self.head = None # Head of list # Method to reverse the list def reverse(self, head): # If head is empty or has reached the list end if head is None or head.next is None: return head # Reverse the rest list rest = self.reverse(head.next) # Put first element at the end head.next.next = head head.next = None # Fix the header pointer return rest # Returns the linked list in display format def __str__(self): linkedListStr = "" temp = self.head while temp: linkedListStr = (linkedListStr + str(temp.data) + " ") temp = temp.next return linkedListStr # Pushes new data to the head of the list def push(self, data): temp = Node(data) temp.next = self.head self.head = temp# Driver codelinkedList = LinkedList()linkedList.push(20)linkedList.push(4)linkedList.push(15)linkedList.push(85)print("Given linked list")print(linkedList)linkedList.head = linkedList.reverse(linkedList.head)print("Reversed linked list")print(linkedList)# This code is contributed by Debidutta Rath |
C#
// Recursive C# program to// reverse a linked listusing System;class recursion{ // Head of liststatic Node head;public class Node{ public int data; public Node next; public Node(int d) { data = d; next = null; }}static Node reverse(Node head){ if (head == null || head.next == null) return head; // Reverse the rest list and put // the first element at the end Node rest = reverse(head.next); head.next.next = head; // Tricky step -- // see the diagram head.next = null; // Fix the head pointer return rest;}// Function to print// linked liststatic void print(){ Node temp = head; while (temp != null) { Console.Write(temp.data + " "); temp = temp.next; } Console.WriteLine();}static void push(int data){ Node temp = new Node(data); temp.next = head; head = temp;}// Driver codepublic static void Main(String []args){ // Start with the // empty list push(20); push(4); push(15); push(85); Console.WriteLine("Given linked list"); print(); head = reverse(head); Console.WriteLine("Reversed Linked list"); print();}}// This code is contributed by gauravrajput1 |
Output:
Given linked list 85 15 4 20 Reversed Linked list 20 4 15 85
Time Complexity: O(n)
Space Complexity: O(1)
A Simpler and Tail Recursive Method
Below is the implementation of this method.
C++
// A simple and tail recursive C++ program to reverse// a linked list#include <bits/stdc++.h>using namespace std;struct Node { int data; struct Node* next;};void reverseUtil(Node* curr, Node* prev, Node** head);// This function mainly calls reverseUtil()// with prev as NULLvoid reverse(Node** head){ if (!head) return; reverseUtil(*head, NULL, head);}// A simple and tail-recursive function to reverse// a linked list. prev is passed as NULL initially.void reverseUtil(Node* curr, Node* prev, Node** head){ /* If last node mark it head*/ if (!curr->next) { *head = curr; /* Update next to prev node */ curr->next = prev; return; } /* Save curr->next node for recursive call */ Node* next = curr->next; /* and update next ..*/ curr->next = prev; reverseUtil(next, curr, head);}// A utility function to create a new nodeNode* newNode(int key){ Node* temp = new Node; temp->data = key; temp->next = NULL; return temp;}// A utility function to print a linked listvoid printlist(Node* head){ while (head != NULL) { cout << head->data << " "; head = head->next; } cout << endl;}// Driver codeint main(){ Node* head1 = newNode(1); head1->next = newNode(2); head1->next->next = newNode(3); head1->next->next->next = newNode(4); head1->next->next->next->next = newNode(5); head1->next->next->next->next->next = newNode(6); head1->next->next->next->next->next->next = newNode(7); head1->next->next->next->next->next->next->next = newNode(8); cout << "Given linked list\n"; printlist(head1); reverse(&head1); cout << "\nReversed linked list\n"; printlist(head1); return 0;} |
Java
// Java program for reversing the Linked listclass LinkedList { static Node head; static class Node { int data; Node next; Node(int d) { data = d; next = null; } } // A simple and tail recursive function to reverse // a linked list. prev is passed as NULL initially. Node reverseUtil(Node curr, Node prev) { /*If head is initially null OR list is empty*/ if (head == null) return head; /* If last node mark it head*/ if (curr.next == null) { head = curr; /* Update next to prev node */ curr.next = prev; return head; } /* Save curr->next node for recursive call */ Node next1 = curr.next; /* and update next ..*/ curr.next = prev; reverseUtil(next1, curr); return head; } // prints content of double linked list void printList(Node node) { while (node != null) { System.out.print(node.data + " "); node = node.next; } } // Driver Code public static void main(String[] args) { LinkedList list = new LinkedList(); list.head = new Node(1); list.head.next = new Node(2); list.head.next.next = new Node(3); list.head.next.next.next = new Node(4); list.head.next.next.next.next = new Node(5); list.head.next.next.next.next.next = new Node(6); list.head.next.next.next.next.next.next = new Node(7); list.head.next.next.next.next.next.next.next = new Node(8); System.out.println("Original Linked list "); list.printList(head); Node res = list.reverseUtil(head, null); System.out.println(""); System.out.println(""); System.out.println("Reversed linked list "); list.printList(res); }}// This code has been contributed by Mayank Jaiswal |
Python
# Simple and tail recursive Python program to# reverse a linked list# Node classclass Node: # Constructor to initialize the node object def __init__(self, data): self.data = data self.next = Noneclass LinkedList: # Function to initialize head def __init__(self): self.head = None def reverseUtil(self, curr, prev): # If last node mark it head if curr.next is None: self.head = curr # Update next to prev node curr.next = prev return # Save curr.next node for recursive call next = curr.next # And update next curr.next = prev self.reverseUtil(next, curr) # This function mainly calls reverseUtil() # with previous as None def reverse(self): if self.head is None: return self.reverseUtil(self.head, None) # Function to insert a new node at the beginning def push(self, new_data): new_node = Node(new_data) new_node.next = self.head self.head = new_node # Utility function to print the linked LinkedList def printList(self): temp = self.head while(temp): print temp.data, temp = temp.next# Driver codellist = LinkedList()llist.push(8)llist.push(7)llist.push(6)llist.push(5)llist.push(4)llist.push(3)llist.push(2)llist.push(1)print "Given linked list"llist.printList()llist.reverse()print "\nReverse linked list"llist.printList()# This code is contributed by Nikhil Kumar Singh(nickzuck_007) |
C#
// C# program for reversing the Linked listusing System;public class LinkedList { Node head; public class Node { public int data; public Node next; public Node(int d) { data = d; next = null; } } // A simple and tail-recursive function to reverse // a linked list. prev is passed as NULL initially. Node reverseUtil(Node curr, Node prev) { /* If last node mark it head*/ if (curr.next == null) { head = curr; /* Update next to prev node */ curr.next = prev; return head; } /* Save curr->next node for recursive call */ Node next1 = curr.next; /* and update next ..*/ curr.next = prev; reverseUtil(next1, curr); return head; } // prints content of double linked list void printList(Node node) { while (node != null) { Console.Write(node.data + " "); node = node.next; } } // Driver code public static void Main(String[] args) { LinkedList list = new LinkedList(); list.head = new Node(1); list.head.next = new Node(2); list.head.next.next = new Node(3); list.head.next.next.next = new Node(4); list.head.next.next.next.next = new Node(5); list.head.next.next.next.next.next = new Node(6); list.head.next.next.next.next.next.next = new Node(7); list.head.next.next.next.next.next.next.next = new Node(8); Console.WriteLine("Original Linked list "); list.printList(list.head); Node res = list.reverseUtil(list.head, null); Console.WriteLine(""); Console.WriteLine(""); Console.WriteLine("Reversed linked list "); list.printList(res); }}// This code contributed by Rajput-Ji |
Output
Given linked list 1 2 3 4 5 6 7 8 Reversed linked list 8 7 6 5 4 3 2 1
Using Stack:
- Store the nodes(values and address) in the stack until all the values are entered.
- Once all entries are done, Update the Head pointer to the last location(i.e the last value).
- Start popping the nodes(value and address) and store them in the same order until the stack is empty.
- Update the next pointer of last Node in the stack by NULL.
Below is the implementation of the above approach:
C++
// C++ program for above approach#include <bits/stdc++.h>#include <iostream>using namespace std;// Create a class Node to enter// values and address in the listclass Node{public: int data; Node* next;};// Function to reverse the// linked listvoid reverseLL(Node** head){ // Create a stack "s" // of Node type stack<Node*> s; Node* temp = *head; while (temp->next != NULL) { // Push all the nodes // in to stack s.push(temp); temp = temp->next; } *head = temp; while (!s.empty()) { // Store the top value of // stack in list temp->next = s.top(); // Pop the value from stack s.pop(); // update the next pointer in the // in the list temp = temp->next; } temp->next = NULL;}// Function to Display// the elements in Listvoid printlist(Node* temp){ while (temp != NULL) { cout << temp->data << " "; temp = temp->next; }}// Program to insert back of the// linked listvoid insert_back(Node** head, int value){ // we have used insertion at back method // to enter values in the list.(eg: // head->1->2->3->4->Null) Node* temp = new Node(); temp->data = value; temp->next = NULL; // If *head equals to NULL if (*head == NULL) { *head = temp; return; } else { Node* last_node = *head; while (last_node->next != NULL) { last_node = last_node->next; } last_node->next = temp; return; }}// Driver Codeint main(){ Node* head = NULL; insert_back(&head, 1); insert_back(&head, 2); insert_back(&head, 3); insert_back(&head, 4); cout << "Given linked list\n"; printlist(head); reverseLL(&head); cout << "\nReversed linked list\n"; printlist(head); return 0;} |
Java
// Java program for above approachimport java.util.*;class GFG{// Create a class Node to enter// values and address in the liststatic class Node{ int data; Node next;};static Node head = null;// Function to reverse the// linked liststatic void reverseLL(){ // Create a stack "s" // of Node type Stack<Node> s = new Stack<>(); Node temp = head; while (temp.next != null) { // Push all the nodes // in to stack s.add(temp); temp = temp.next; } head = temp; while (!s.isEmpty()) { // Store the top value of // stack in list temp.next = s.peek(); // Pop the value from stack s.pop(); // update the next pointer in the // in the list temp = temp.next; } temp.next = null;}// Function to Display// the elements in Liststatic void printlist(Node temp){ while (temp != null) { System.out.print(temp.data+ " "); temp = temp.next; }}// Program to insert back of the// linked liststatic void insert_back( int value){ // we have used insertion at back method // to enter values in the list.(eg: // head.1.2.3.4.Null) Node temp = new Node(); temp.data = value; temp.next = null; // If *head equals to null if (head == null) { head = temp; return; } else { Node last_node = head; while (last_node.next != null) { last_node = last_node.next; } last_node.next = temp; return; }}// Driver Codepublic static void main(String[] args){ insert_back( 1); insert_back( 2); insert_back(3); insert_back( 4); System.out.print("Given linked list\n"); printlist(head); reverseLL(); System.out.print("\nReversed linked list\n"); printlist(head);}}// This codeis contributed by gauravrajput1 |
C#
// C# program for above approachusing System;using System.Collections.Generic;class GFG{// Create a class Node to enter// values and address in the listpublic class Node{ public int data; public Node next;};static Node head = null;// Function to reverse the// linked liststatic void reverseLL(){ // Create a stack "s" // of Node type Stack<Node> s = new Stack<Node>(); Node temp = head; while (temp.next != null) { // Push all the nodes // in to stack s.Push(temp); temp = temp.next; } head = temp; while (s.Count != 0) { // Store the top value of // stack in list temp.next = s.Peek(); // Pop the value from stack s.Pop(); // Update the next pointer in the // in the list temp = temp.next; } temp.next = null;}// Function to Display// the elements in Liststatic void printlist(Node temp){ while (temp != null) { Console.Write(temp.data + " "); temp = temp.next; }}// Function to insert back of the// linked liststatic void insert_back( int value){ // We have used insertion at back method // to enter values in the list.(eg: // head.1.2.3.4.Null) Node temp = new Node(); temp.data = value; temp.next = null; // If *head equals to null if (head == null) { head = temp; return; } else { Node last_node = head; while (last_node.next != null) { last_node = last_node.next; } last_node.next = temp; return; }}// Driver Codepublic static void Main(String[] args){ insert_back(1); insert_back(2); insert_back(3); insert_back(4); Console.Write("Given linked list\n"); printlist(head); reverseLL(); Console.Write("\nReversed linked list\n"); printlist(head);}}// This code is contributed by gauravrajput1 |
Python3
# Python code for the above approach# Definition for singly-linked list.class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = nextclass Solution: # Program to reverse the linked list # using stack def reverseLLUsingStack(self, head): # Initialise the variables stack, temp = [], head while temp: stack.append(temp) temp = temp.next head = temp = stack.pop() # Untill stack is not # empty while len(stack) > 0: elem = stack.pop() temp.next = elem temp = elem elem.next = None return head# Driver Codeif __name__ == "__main__": head = ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5))))) obj = Solution() head = obj.reverseLLUsingStack(head) while head: print(head.val, end=' ') head = head.next |
Output
Given linked list 1 2 3 4 Reversed linked list 4 3 2 1
Thanks to Gaurav Ahirwar for suggesting this solution.
Using array:
1. Create a linked list,
2. Then, make a count(head) function to count the number of nodes,
3. Initialize an array with the size of the count,
4. and start a while(p->next!=NULL) loop and store all the node’s data into the array,
5. and then print the array from the last index to the first.
C++
#include <iostream>#include<cstdlib>using namespace std;typedef struct node{ int val; struct node* next;}node;node* head=NULL;int count(node* head) // code to count the no. of nodes{ node* p=head; int k=1; while(p!=NULL) { p=p->next; k++; } return k;}node *ll_reverse(node* head) // to reverse the linked list{ node* p=head; long int i=count(head),j=1; long int arr[i]; while(i && p!=NULL) { arr[j++]=p->val; p=p->next; i--; } j--; while(j) // loop will break as soon as j=0 { cout<<arr[j--]<<" "; } return head;}node* insert_end(node* head,int data) //code to insert at end of ll{ node* q=head,*p=(node*)malloc(sizeof(node)); p->val=data; while(q->next!=NULL) { q=q->next; } q->next=p; p->next=NULL; return head;}node *create_ll(node* head,int data) //create ll{ node* p=(node*)malloc(sizeof(node)); p->val=data; if(head==NULL) { head=p; p->next=NULL; return head; } else { head=insert_end(head,data); return head; }}//Driver codeint main(){ int i=5,j=1; while(i--) { head=create_ll(head,j++); } head=ll_reverse(head); return 0;} |
Input : 1->2->3->4->5 Output: 5->4->3->2->1
Time complexity: O(n) Space complexity: O(1)
Recursively Reversing a linked list (A simple implementation)
Iteratively Reverse a linked list using only 2 pointers (An Interesting Method)
References:
http://cslibrary.stanford.edu/105/LinkedListProblems.pdf
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.
