Open In App

# Recursively Reversing a linked list (A simple implementation)

Given pointer to the head node of a linked list, the task is to recursively reverse the linked list. We need to reverse the list by changing 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->NULL

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

Input : NULL
Output : NULL

Input  : 1->NULL
Output : 1->NULL```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

We have discussed an iterative and two recursive approaches in previous post on reverse a linked list. In this approach of reversing a linked list by passing a single pointer what we are trying to do is that we are making the previous node of the current node as his next node to reverse the linked list.

1. We return the pointer of next node to his previous(current) node and then make the previous node as the next node of returned node and then return the current node.
2. We first traverse to the last node and make the last node the head node of reversed linked list and then apply the above procedure in a recursive manner.

Implementation:

## C++

 `// Recursive C++ program to reverse``// a linked list``#include ``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 */``    ``Node* reverse(Node* node)``    ``{``        ``if` `(node == NULL)``            ``return` `NULL;``        ``if` `(node->next == NULL) {``            ``head = node;``            ``return` `node;``        ``}``        ``Node* node1 = reverse(node->next);``        ``node1->next = node;``        ``node->next = NULL;``        ``return` `node;``    ``}` `    ``/* 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.reverse(ll.head);` `    ``cout << ``"\nReversed Linked list \n"``;``    ``ll.print();``    ``return` `0;``}`

## Java

 `// Recursive Java program to reverse``// a linked list``import` `java.io.BufferedWriter;``import` `java.io.IOException;``import` `java.io.OutputStreamWriter;``import` `java.util.Scanner;` `public` `class` `ReverseLinkedListRecursive {``    ` `    ``/* Link list node */``    ``static` `class` `Node {``        ``public` `int` `data;``        ``public` `Node next;` `        ``public` `Node(``int` `nodeData) {``            ``this``.data = nodeData;``            ``this``.next = ``null``;``        ``}``    ``}` `    ``static` `class` `LinkedList {``        ``public` `Node head;` `        ``public` `LinkedList() {``            ``this``.head = ``null``;``        ``}` `        ``public` `void` `insertNode(``int` `nodeData) {``            ``Node node = ``new` `Node(nodeData);` `            ``if` `(``this``.head != ``null``) {``                ``node.next = head;``            ``}``            ``this``.head = node;``        ``}``    ``}` `    ``/* Function to print linked list */``    ``public` `static` `void` `printSinglyLinkedList(Node node,``                        ``String sep) ``throws` `IOException {``        ``while` `(node != ``null``) {``            ``System.out.print(String.valueOf(node.data) + sep);``            ``node = node.next;``        ``}``    ``}` `    ``// Complete the reverse function below.``    ``static` `Node reverse(Node head) {``        ``if``(head == ``null``) {``            ``return` `head;``        ``}` `        ``// last node or only one node``        ``if``(head.next == ``null``) {``            ``return` `head;``        ``}` `        ``Node newHeadNode = reverse(head.next);` `        ``// change references for middle chain``        ``head.next.next = head;``        ``head.next = ``null``;` `        ``// send back new head node in every recursion``        ``return` `newHeadNode;``    ``}` `    ``private` `static` `final` `Scanner scanner = ``new` `Scanner(System.in);` `    ``public` `static` `void` `main(String[] args) ``throws` `IOException {``            ``LinkedList llist = ``new` `LinkedList();``        ` `            ``llist.insertNode(``20``);``            ``llist.insertNode(``4``);``            ``llist.insertNode(``15``);``            ``llist.insertNode(``85``);``            ` `            ``System.out.println(``"Given linked list:"``);``            ``printSinglyLinkedList(llist.head, ``" "``);``            ` `            ``System.out.println();``            ``System.out.println(``"Reversed Linked list:"``);``            ``Node llist1 = reverse(llist.head);``            ``printSinglyLinkedList(llist1, ``" "``);` `        ``scanner.close();``    ``}``}`

## Python3

 `# Recursive Python3 program to reverse``# a linked list``import` `math` `# Link list node``class` `Node:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.``next` `=` `None``    ` `def` `LinkedList():``    ``head ``=` `None``        ` `# Function to reverse the linked list``def` `reverse(node):``    ``if` `(node ``=``=` `None``):``        ``return` `node``        ` `    ``if` `(node.``next` `=``=` `None``):``        ``return` `node``        ` `    ``node1 ``=` `reverse(node.``next``)``    ``node.``next``.``next` `=` `node``    ``node.``next` `=` `None``    ``return` `node1` `# Function to print linked list``def` `printList():``    ``temp ``=` `head``    ``while` `(temp !``=` `None``) :``        ``print``(temp.data, end ``=` `" "``)``        ``temp ``=` `temp.``next``        ` `def` `push(head_ref, new_data):``    ``new_node ``=` `Node(new_data)``    ``new_node.data ``=` `new_data``    ``new_node.``next` `=` `head_ref``    ``head_ref ``=` `new_node``    ``return` `head_ref` `# Driver Code``if` `__name__``=``=``'__main__'``:``    ` `    ``# Start with the empty list``    ``head ``=` `LinkedList()``    ``head ``=` `push(head, ``20``)``    ``head ``=` `push(head, ``4``)``    ``head ``=` `push(head, ``15``)``    ``head ``=` `push(head, ``85``)` `    ``print``(``"Given linked list"``)``    ``printList()` `    ``head ``=` `reverse(head)` `    ``print``(``"\nReversed Linked list"``)``    ``printList()``    ` `# This code is contributed by AbhiThakur`

## C#

 `// Recursive C# program to reverse``// a linked list``using` `System;` `public` `class` `ReverseLinkedListRecursive``{``    ` `    ``/* Link list node */``    ``public` `class` `Node``    ``{``        ``public` `int` `data;``        ``public` `Node next;` `        ``public` `Node(``int` `nodeData)``        ``{``            ``this``.data = nodeData;``            ``this``.next = ``null``;``        ``}``    ``}` `    ``class` `LinkedList``    ``{``        ``public` `Node head;` `        ``public` `LinkedList()``        ``{``            ``this``.head = ``null``;``        ``}` `        ``public` `void` `insertNode(``int` `nodeData)``        ``{``            ``Node node = ``new` `Node(nodeData);` `            ``if` `(``this``.head != ``null``)``            ``{``                ``node.next = head;``            ``}``            ``this``.head = node;``        ``}``    ``}` `    ``/* Function to print linked list */``    ``public` `static` `void` `printSinglyLinkedList(Node node,``                        ``String sep)``    ``{``        ``while` `(node != ``null``)``        ``{``            ``Console.Write(node.data + sep);``            ``node = node.next;``        ``}``    ``}` `    ``// Complete the reverse function below.``    ``static` `Node reverse(Node head)``    ``{``        ``if``(head == ``null``)``        ``{``            ``return` `head;``        ``}` `        ``// last node or only one node``        ``if``(head.next == ``null``)``        ``{``            ``return` `head;``        ``}` `        ``Node newHeadNode = reverse(head.next);` `        ``// change references for middle chain``        ``head.next.next = head;``        ``head.next = ``null``;` `        ``// send back new head``        ``// node in every recursion``        ``return` `newHeadNode;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``            ``LinkedList llist = ``new` `LinkedList();``        ` `            ``llist.insertNode(20);``            ``llist.insertNode(4);``            ``llist.insertNode(15);``            ``llist.insertNode(85);``            ` `            ``Console.WriteLine(``"Given linked list:"``);``            ``printSinglyLinkedList(llist.head, ``" "``);``            ` `            ``Console.WriteLine();``            ``Console.WriteLine(``"Reversed Linked list:"``);``            ``Node llist1 = reverse(llist.head);``            ``printSinglyLinkedList(llist1, ``" "``);``    ``}``}` `// This code has been contributed by Rajput-Ji`

## Javascript

 `// Recursive JavaScript program to reverse``// a linked list` `// Link List node``class Node{``    ``constructor(data){``        ``this``.data = data;``        ``this``.next = ``null``;``    ``}``}``let head = ``null``;``// Function to reverse the linked list``function` `reverse(node){``    ``if``(node == ``null``) ``return` `null``;``    ` `    ``if``(node.next == ``null``){``        ``head = node;``        ``return` `node;``    ``}``    ` `    ``let node1 = reverse(node.next);``    ``node1.next = node;``    ``node.next = ``null``;``    ``return` `node;``}` `// Function to print linked list``function` `print(){``    ``let temp = head;``    ``while``(temp != ``null``){``        ``console.log(temp.data + ``" "``);``        ``temp = temp.next;``    ``}``}` `function` `push(data){``    ``let temp = ``new` `Node(data);``    ``temp.next = head;``    ``head = temp;``}` `// Driver Code``push(20);``push(4);``push(15);``push(85);` `console.log(``"Given Linked List "``);``print();` `reverse(head)` `console.log(``"\nReversed Linked List"``);``print();` `// This code is contributed by Yash Agarwal(yashagarwal2852002)`

Output

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

Time Complexity: O(N) where N is the number of elements in the linked list.
Auxiliary Space: O(N) due to stack recursion call.

Reverse a linked list by Tail Recursive Method:
Follow the steps below to solve the problem:
1) First update next with next node of current i.e. next = current->next
2) Now make a reverse link from current node to previous node i.e. curr->next = prev
3) If the visited node is the last node then just make a reverse link from the current node to previous node and update head.
Below is the implementation of the above approach:

## C++

 `// A simple and tail recursive C++ program to reverse``// a linked list``#include ``using` `namespace` `std;` `struct` `Node {``    ``int` `data;``    ``struct` `Node* next;``    ``Node(``int` `data){``        ``this``->data = data;``        ``this``->next = NULL;``    ``}``};` `// 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);``}` `// This function mainly calls reverseUtil()``// with prev as NULL``void` `reverse(Node** head){``    ``if` `(!head)``        ``return``;``    ``reverseUtil(*head, NULL, head);``}` `// A utility function to print a linked list``void` `printlist(Node* head){``    ``while` `(head != NULL) {``        ``cout << head->data << ``" "``;``        ``head = head->next;``    ``}``}` `// Driver code to test above function``int` `main(){``    ``Node* head1 = ``new` `Node(1);``    ``head1->next = ``new` `Node(2);``    ``head1->next->next = ``new` `Node(3);``    ``head1->next->next->next = ``new` `Node(4);``    ``head1->next->next->next->next = ``new` `Node(5);``    ``head1->next->next->next->next->next = ``new` `Node(6);``    ``head1->next->next->next->next->next->next = ``new` `Node(7);``    ``head1->next->next->next->next->next->next->next= ``new` `Node(8);``    ``cout << ``"Given linked list\n"``;``    ``printlist(head1);``    ``cout<

## Java

 `// A simple and tail recursive Java program to reverse``// a linked list``import` `java.io.*;``import` `java.util.*;` `// Linked List Node class``class` `Node {``    ``int` `data;``    ``Node next;` `    ``Node(``int` `data) {``        ``this``.data = data;``        ``this``.next = ``null``;``    ``}``}` `// Linked List class``class` `LinkedList {``    ``Node head;` `    ``// A simple and tail-recursive function to reverse``    ``// a linked list. prev is passed as null initially.``    ``void` `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``;``        ``}``        ``/* Save curr.next node for recursive call */``        ``Node next = curr.next;``        ``/* and update next ..*/``        ``curr.next = prev;``        ``reverseUtil(next, curr);``    ``}` `    ``// This function mainly calls reverseUtil()``    ``// with prev as null``    ``void` `reverse() {``        ``if` `(head == ``null``)``            ``return``;``        ``reverseUtil(head, ``null``);``    ``}` `    ``// A utility function to print a linked list``    ``void` `printList() {``        ``Node temp = head;``        ``while` `(temp != ``null``) {``            ``System.out.print(temp.data + ``" "``);``            ``temp = temp.next;``        ``}``    ``}``}` `// Driver code to test above function``class` `Main {``    ``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(``"Given linked list"``);``        ``list.printList();``        ``System.out.println();``        ``list.reverse();``        ``System.out.println(``"Reversed linked list"``);``        ``list.printList();``    ``}``}`

## Python3

 `# A simple and tail recursive Python program to reverse``# a linked list``class` `Node:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.``next` `=` `None``    ` `head1 ``=` `None` `# a simple and tail-reverse function to reverse``# a linked list. prev is passed as null initially.``def` `reverseUtil(curr, prev):``  ` `    ``# if last node mark it head``    ``if``(curr.``next` `is` `None``):``        ``global` `head1``        ``head1 ``=` `curr``        ``# update next to prev node``        ``curr.``next` `=` `prev``        ``return``    ` `    ``# save curr.next node from recursive call``    ``next` `=` `curr.``next``    ``curr.``next` `=` `prev``    ``reverseUtil(``next``, curr)``    `  `# this function mainly calls reverseUtil()``# with prev as null``def` `reverse():``    ``global` `head1``    ``if``(head1 ``is` `None``):``        ``return``    ``reverseUtil(head1, ``None``)``    ` `# utility function to print a linked list``def` `printlist(head):``    ``while``(head ``is` `not` `None``):``        ``print``(head.data , end ``=` `" "``)``        ``head ``=` `head.``next``    ``print``("")` `# driver program to test above function``head1 ``=` `Node(``1``)``head1.``next` `=` `Node(``2``)``head1.``next``.``next` `=` `Node(``3``)``head1.``next``.``next``.``next` `=` `Node(``4``)``head1.``next``.``next``.``next``.``next` `=` `Node(``5``)``head1.``next``.``next``.``next``.``next``.``next` `=` `Node(``6``)``head1.``next``.``next``.``next``.``next``.``next``.``next` `=` `Node(``7``)``head1.``next``.``next``.``next``.``next``.``next``.``next``.``next``=` `Node(``8``)``    ` `print``(``"Given Linked List : "``)``printlist(head1)` `reverse()` `print``(``"Reversed Linked List : "``)``printlist(head1)`

## C#

 `using` `System;` `// A simple C# program to represent a node in a linked list``public` `class` `Node {``    ``public` `int` `data;``    ``public` `Node next;``    ``public` `Node(``int` `data) {``        ``this``.data = data;``        ``this``.next = ``null``;``    ``}``}` `public` `class` `LinkedList {``    ``public` `static` `Node head1 = ``null``;` `    ``// A simple and tail-recursive function to reverse a linked list``    ``// prev is passed as null initially.``    ``public` `static` `void` `reverseUtil(Node curr, Node prev) {``        ``// If last node, mark it as head``        ``if` `(curr.next == ``null``) {``            ``head1 = curr;``            ``// Update next to prev node``            ``curr.next = prev;``            ``return``;``        ``}` `        ``// Save curr.next node from recursive call``        ``Node next = curr.next;``        ``curr.next = prev;``        ``reverseUtil(next, curr);``    ``}` `    ``// This function mainly calls reverseUtil() with prev as null``    ``public` `static` `void` `reverse() {``        ``if` `(head1 == ``null``) {``            ``return``;``        ``}``        ``reverseUtil(head1, ``null``);``    ``}` `    ``// Utility function to print a linked list``    ``public` `static` `void` `printlist(Node head) {``        ``while` `(head != ``null``) {``            ``Console.Write(head.data + ``" "``);``            ``head = head.next;``        ``}``        ``Console.WriteLine();``    ``}` `    ``// Driver code to test above functions``    ``public` `static` `void` `Main() {``        ``head1 = ``new` `Node(1);``        ``head1.next = ``new` `Node(2);``        ``head1.next.next = ``new` `Node(3);``        ``head1.next.next.next = ``new` `Node(4);``        ``head1.next.next.next.next = ``new` `Node(5);``        ``head1.next.next.next.next.next = ``new` `Node(6);``        ``head1.next.next.next.next.next.next = ``new` `Node(7);``        ``head1.next.next.next.next.next.next.next = ``new` `Node(8);` `        ``Console.Write(``"Given Linked List : "``);``        ``printlist(head1);` `        ``reverse();` `        ``Console.Write(``"Reversed Linked List : "``);``        ``printlist(head1);``    ``}``}`

## Javascript

 `// A simple and tail recursive C++ Program to reverse``// a linked list``class Node{``    ``constructor(data){``        ``this``.data = data;``        ``this``.next = ``null``;``    ``}``}` `let head1 = ``null``;` `// A simple and tail-recursive function to reverse``// a linked list. prev is passed as NULL initially.``function` `reverseUtil(curr, prev){` `    ``// if last node mark it head``    ``if``(!curr.next){``        ``head1 = curr;``        ` `        ``// update next to prev node``        ``curr.next = prev;``        ``return``;``    ``}``    ` `    ``// save curr.next node fro recursive call``    ``let next = curr.next;``    ``curr.next = prev;``    ``reverseUtil(next, curr);``}` `// this function mainly calls reverseUtil()``// with prev as null``function` `reverse(){``    ``if``(head1 == ``null``) ``return``;``    ``reverseUtil(head1, ``null``);``}` `// a utility function to print a linked list``function` `printlist(head){``    ``while``(head != ``null``){``        ``console.log(head.data + ``" "``);``        ``head = head.next;``    ``}``}` `// driver code to test above function``head1 = ``new` `Node(1);``head1.next = ``new` `Node(2);``head1.next.next = ``new` `Node(3);``head1.next.next.next = ``new` `Node(4);``head1.next.next.next.next = ``new` `Node(5);``head1.next.next.next.next.next = ``new` `Node(6);``head1.next.next.next.next.next.next = ``new` `Node(7);``head1.next.next.next.next.next.next.next= ``new` `Node(8);` `console.log(``"Given Linked List : "``);``printlist(head1);` `reverse();` `console.log(``"Reversed Linked List : "``);``printlist(head1);`

Output

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