Reverse a Doubly linked list using recursion

Last Updated : 17 Jan, 2023

Given a doubly linked list. Reverse it using recursion.

Original Doubly linked list

Reversed Doubly linked list

We have discussed
Iterative solution to reverse a Doubly Linked List

Algorithm:

If list is empty, return
Reverse head by swapping head->prev and head->next
If prev = NULL it means that list is fully reversed. Else reverse(head->prev)

Implementation:

C++

// C++ implementation to reverse a doubly
// linked list using recursion
#include <bits/stdc++.h>
using namespace std;

// a node of the doubly linked list
struct Node {
    int data;
    Node *next, *prev;
};

// function to get a new node
Node* getNode(int data)
{
    // allocate space
    Node* new_node = new Node;
    new_node->data = data;
    new_node->next = new_node->prev = NULL;
    return new_node;
}

// function to insert a node at the beginning
// of the Doubly Linked List
void push(Node** head_ref, Node* new_node)
{
    // since we are adding at the beginning,
    // prev is always NULL
    new_node->prev = NULL;

    // link the old list of the new node
    new_node->next = (*head_ref);

    // change prev of head node to new node
    if ((*head_ref) != NULL)
        (*head_ref)->prev = new_node;

    // move the head to point to the new node
    (*head_ref) = new_node;
}

// function to reverse a doubly linked list
Node* Reverse(Node* node)
{
    // If empty list, return
    if (!node)
        return NULL;

    // Otherwise, swap the next and prev
    Node* temp = node->next;
    node->next = node->prev;
    node->prev = temp;

    // If the prev is now NULL, the list
    // has been fully reversed
    if (!node->prev)
        return node;

    // Otherwise, keep going
    return Reverse(node->prev);
}

// Function to print nodes in a given doubly
// linked list
void printList(Node* head)
{
    while (head != NULL) {
        cout << head->data << " ";
        head = head->next;
    }
}

// Driver program to test above
int main()
{
    // Start with the empty list
    Node* head = NULL;

    // Create doubly linked: 10<->8<->4<->2 */
    push(&head, getNode(2));
    push(&head, getNode(4));
    push(&head, getNode(8));
    push(&head, getNode(10));
    cout << "Original list: ";
    printList(head);

    // Reverse doubly linked list
    head = Reverse(head);
    cout << "\nReversed list: ";
    printList(head);
    return 0;
}

Java

// Java implementation to reverse a doubly 
// linked list using recursion 
class GFG
{
    
// a node of the doubly linked list 
static class Node 
{ 
    int data; 
    Node next, prev; 
}; 

// function to get a new node 
static Node getNode(int data) 
{ 
    // allocate space 
    Node new_node = new Node(); 
    new_node.data = data; 
    new_node.next = new_node.prev = null; 
    return new_node; 
} 

// function to insert a node at the beginning 
// of the Doubly Linked List 
static Node push(Node head_ref, Node new_node) 
{ 
    // since we are adding at the beginning, 
    // prev is always null 
    new_node.prev = null; 

    // link the old list of the new node 
    new_node.next = (head_ref); 

    // change prev of head node to new node 
    if ((head_ref) != null) 
        (head_ref).prev = new_node; 

    // move the head to point to the new node 
    (head_ref) = new_node; 
    return head_ref;
} 

// function to reverse a doubly linked list 
static Node Reverse(Node node) 
{ 
    // If empty list, return 
    if (node == null) 
        return null; 

    // Otherwise, swap the next and prev 
    Node temp = node.next; 
    node.next = node.prev; 
    node.prev = temp; 

    // If the prev is now null, the list 
    // has been fully reversed 
    if (node.prev == null) 
        return node; 

    // Otherwise, keep going 
    return Reverse(node.prev); 
} 

// Function to print nodes in a given doubly 
// linked list 
static void printList(Node head) 
{ 
    while (head != null)
    { 
        System.out.print( head.data + " "); 
        head = head.next; 
    } 
} 

// Driver code 
public static void main(String args[]) 
{ 
    // Start with the empty list 
    Node head = null; 

    // Create doubly linked: 10<.8<.4<.2 / 
    head = push(head, getNode(2)); 
    head = push(head, getNode(4)); 
    head = push(head, getNode(8)); 
    head = push(head, getNode(10)); 
    System.out.print( "Original list: "); 
    printList(head); 

    // Reverse doubly linked list 
    head = Reverse(head); 
    System.out.print("\nReversed list: "); 
    printList(head); 
} 
}

// This code is contributed by Arnab Kundu

Python3

# Python3 implementation to reverse a doubly
# linked list using recursion
import math

# a node of the doubly linked list
class Node: 
    def __init__(self, data): 
        self.data = data 
        self.next = None

# function to get a new node
def getNode(data):
    
    # allocate space
    new_node = Node(data)
    new_node.data = data
    new_node.next = new_node.prev = None
    return new_node

# function to insert a node at the beginning
# of the Doubly Linked List
def push(head_ref, new_node):
    
    # since we are adding at the beginning,
    # prev is always None
    new_node.prev = None

    # link the old list of the new node
    new_node.next = head_ref

    # change prev of head node to new node
    if (head_ref != None):
        head_ref.prev = new_node

    # move the head to point to the new node
    head_ref = new_node
    return head_ref

# function to reverse a doubly linked list
def Reverse(node):
    
    # If empty list, return
    if not node:
        return None

    # Otherwise, swap the next and prev
    temp = node.next
    node.next = node.prev
    node.prev = temp

    # If the prev is now None, the list
    # has been fully reversed
    if not node.prev:
        return node

    # Otherwise, keep going
    return Reverse(node.prev)

# Function to print nodes in a given doubly
# linked list
def printList(head):
    while (head != None) :
        print(head.data, end = " ")
        head = head.next
    
# Driver Code
if __name__=='__main__': 
    
    # Start with the empty list
    head = None

    # Create doubly linked: 10<.8<.4<.2 */
    head = push(head, getNode(2)); 
    head = push(head, getNode(4)); 
    head = push(head, getNode(8)); 
    head = push(head, getNode(10));
    print("Original list: ", end = "")
    printList(head)
    
    # Reverse doubly linked list
    head = Reverse(head)
    print("\nReversed list: ", end = "")
    printList(head)
    
# This code is contributed by Srathore

 // C# implementation to reverse a doubly 
using System;

// linked list using recursion 
class GFG 
{ 
    
// a node of the doubly linked list 
public class Node 
{ 
    public int data; 
    public Node next, prev; 
}; 

// function to get a new node 
static Node getNode(int data) 
{ 
    // allocate space 
    Node new_node = new Node(); 
    new_node.data = data; 
    new_node.next = new_node.prev = null; 
    return new_node; 
} 

// function to insert a node at the beginning 
// of the Doubly Linked List 
static Node push(Node head_ref, Node new_node) 
{ 
    // since we are adding at the beginning, 
    // prev is always null 
    new_node.prev = null; 

    // link the old list of the new node 
    new_node.next = (head_ref); 

    // change prev of head node to new node 
    if ((head_ref) != null) 
        (head_ref).prev = new_node; 

    // move the head to point to the new node 
    (head_ref) = new_node; 
    return head_ref; 
} 

// function to reverse a doubly linked list 
static Node Reverse(Node node) 
{ 
    // If empty list, return 
    if (node == null) 
        return null; 

    // Otherwise, swap the next and prev 
    Node temp = node.next; 
    node.next = node.prev; 
    node.prev = temp; 

    // If the prev is now null, the list 
    // has been fully reversed 
    if (node.prev == null) 
        return node; 

    // Otherwise, keep going 
    return Reverse(node.prev); 
} 

// Function to print nodes in a given doubly 
// linked list 
static void printList(Node head) 
{ 
    while (head != null) 
    { 
        Console.Write( head.data + " "); 
        head = head.next; 
    } 
} 

// Driver code 
public static void Main(String []argsS) 
{ 
    // Start with the empty list 
    Node head = null; 

    // Create doubly linked: 10<.8<.4<.2 / 
    head = push(head, getNode(2)); 
    head = push(head, getNode(4)); 
    head = push(head, getNode(8)); 
    head = push(head, getNode(10)); 
    Console.Write( "Original list: "); 
    printList(head); 

    // Reverse doubly linked list 
    head = Reverse(head); 
    Console.Write("\nReversed list: "); 
    printList(head); 
} 
} 

// This code is contributed by Arnab Kundu

JavaScript

<script>
// javascript implementation to reverse a doubly 
// linked list using recursion     
// a node of the doubly linked list
class Node {
    constructor(val) {
        this.data = val;
        this.prev = null;
        this.next = null;
    }
}

    // function to get a new node
    function getNode(data) {
        // allocate space
var new_node = new Node();
        new_node.data = data;
        new_node.next = new_node.prev = null;
        return new_node;
    }

    // function to insert a node at the beginning
    // of the Doubly Linked List
    function push(head_ref,  new_node) {
        // since we are adding at the beginning,
        // prev is always null
        new_node.prev = null;

        // link the old list of the new node
        new_node.next = (head_ref);

        // change prev of head node to new node
        if ((head_ref) != null)
            (head_ref).prev = new_node;

        // move the head to point to the new node
        (head_ref) = new_node;
        return head_ref;
    }

    // function to reverse a doubly linked list
    function Reverse(node) {
        // If empty list, return
        if (node == null)
            return null;

        // Otherwise, swap the next and prev
var temp = node.next;
        node.next = node.prev;
        node.prev = temp;

        // If the prev is now null, the list
        // has been fully reversed
        if (node.prev == null)
            return node;

        // Otherwise, keep going
        return Reverse(node.prev);
    }

    // Function to print nodes in a given doubly
    // linked list
    function printList(head) {
        while (head != null) {
            document.write(head.data + " ");
            head = head.next;
        }
    }

    // Driver code
    
        // Start with the empty list
var head = null;

        // Create doubly linked: 10<.8<.4<.2 /
        head = push(head, getNode(2));
        head = push(head, getNode(4));
        head = push(head, getNode(8));
        head = push(head, getNode(10));
        document.write("Original list: ");
        printList(head);

        // Reverse doubly linked list
        head = Reverse(head);
        document.write("<br/>Reversed list: ");
        printList(head);

// This code contributed by umadevi9616
</script>

Output

Original list: 10 8 4 2 
Reversed list: 2 4 8 10

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

Programs for Printing Pyramid Patterns using Recursion

Shahnawaz_Ali

Improve

Article Tags :

Practice Tags :

Reverse a Doubly linked list using recursion

Similar Reads

Thank You!

What kind of Experience do you want to share?