Open In App
Related Articles

Reverse a Doubly Linked List

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given a Doubly Linked List, the task is to reverse the given Doubly Linked List.

Example:

Input:

Output:

Follow the given steps to solve the problem using the above approach:

  • Traverse the linked list using a pointer
  • Swap the prev and next pointers for all nodes
  • At last, change the head pointer of the doubly linked list

Below is the implementation of the above approach:

C

/* Program to reverse a doubly linked list */
 
#include <stdio.h>
#include <stdlib.h>
 
/* a node of the doubly linked list */
struct Node {
    int data;
    struct Node* next;
    struct Node* prev;
};
 
/* Function to reverse a Doubly Linked List */
void reverse(struct Node** head_ref)
{
    struct Node* temp = NULL;
    struct Node* current = *head_ref;
 
    /* swap next and prev for all nodes of
      doubly linked list */
    while (current != NULL) {
        temp = current->prev;
        current->prev = current->next;
        current->next = temp;
        current = current->prev;
    }
 
    /* Before changing head, check for the cases like empty
       list and list with only one node */
    if (temp != NULL)
        *head_ref = temp->prev;
}
 
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginning of the Doubly
 * Linked List */
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;
 
    /* 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 print nodes in a given doubly linked list
   This function is same as printList() of singly linked
   list */
void printList(struct Node* node)
{
    while (node != NULL) {
        printf("%d ", node->data);
        node = node->next;
    }
}
 
// Driver's code
int main()
{
    /* Start with the empty list */
    struct Node* head = NULL;
 
    /* Let us create a sorted linked list to test the
     functions Created linked list will be 10->8->4->2 */
    push(&head, 2);
    push(&head, 4);
    push(&head, 8);
    push(&head, 10);
 
    printf("\n Original Linked list ");
    printList(head);
 
    // Function call
    reverse(&head);
 
    printf("\n Reversed Linked list ");
    printList(head);
 
    getchar();
}

                    

C++

/* C++ program to reverse a doubly linked list */
 
#include <bits/stdc++.h>
using namespace std;
 
/* Node of the doubly linked list */
class Node {
public:
    int data;
    Node* next;
    Node* prev;
};
 
/* Function to reverse a Doubly Linked List */
void reverse(Node** head_ref)
{
    Node* temp = NULL;
    Node* current = *head_ref;
 
    /* swap next and prev for all nodes of
    doubly linked list */
    while (current != NULL) {
        temp = current->prev;
        current->prev = current->next;
        current->next = temp;
        current = current->prev;
    }
 
    /* Before changing the head, check for the cases like
       empty list and list with only one node */
    if (temp != NULL)
        *head_ref = temp->prev;
}
 
/* UTILITY FUNCTIONS */
/* Function to insert a node at the
beginning of the Doubly Linked List */
void push(Node** head_ref, int new_data)
{
    /* allocate node */
    Node* new_node = new Node();
 
    /* put in the data */
    new_node->data = new_data;
 
    /* 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 print nodes in a given doubly linked list
This function is same as printList() of singly linked list
*/
void printList(Node* node)
{
    while (node != NULL) {
        cout << node->data << " ";
        node = node->next;
    }
}
 
// Driver's code
int main()
{
    /* Start with the empty list */
    Node* head = NULL;
 
    /* Let us create a sorted linked list to test the
    functions Created linked list will be 10->8->4->2 */
    push(&head, 2);
    push(&head, 4);
    push(&head, 8);
    push(&head, 10);
 
    cout << "Original Linked list" << endl;
    printList(head);
 
    // Function call
    reverse(&head);
 
    cout << "\nReversed Linked list" << endl;
    printList(head);
 
    return 0;
}
 
// This code is contributed by rathbhupendra

                    

Java

// Java program to reverse a doubly linked list
 
class LinkedList {
 
    static Node head;
 
    static class Node {
 
        int data;
        Node next, prev;
 
        Node(int d)
        {
            data = d;
            next = prev = null;
        }
    }
 
    /* Function to reverse a Doubly Linked List */
    void reverse()
    {
        Node temp = null;
        Node current = head;
 
        /* swap next and prev for all nodes of
         doubly linked list */
        while (current != null) {
            temp = current.prev;
            current.prev = current.next;
            current.next = temp;
            current = current.prev;
        }
 
        /* Before changing head, check for the cases like
         empty list and list with only one node */
        if (temp != null) {
            head = temp.prev;
        }
    }
 
    /* UTILITY FUNCTIONS */
    /* Function to insert a node at the beginning of the
     * Doubly Linked List */
    void push(int new_data)
    {
        /* allocate node */
        Node new_node = new Node(new_data);
 
        /* 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;
 
        /* change prev of head node to new node */
        if (head != null) {
            head.prev = new_node;
        }
 
        /* move the head to point to the new node */
        head = new_node;
    }
 
    /* Function to print nodes in a given doubly linked list
     This function is same as printList() of singly linked
     list */
    void printList(Node node)
    {
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }
    }
 
      // Driver's code
    public static void main(String[] args)
    {
        LinkedList list = new LinkedList();
 
        /* Let us create a sorted linked list to test the
         functions Created linked list will be 10->8->4->2
       */
        list.push(2);
        list.push(4);
        list.push(8);
        list.push(10);
 
        System.out.println("Original linked list ");
        list.printList(head);
         
          // Function call
        list.reverse();
       
        System.out.println("");
        System.out.println("The reversed Linked List is ");
        list.printList(head);
    }
}
 
// This code has been contributed by Mayank Jaiswal

                    

Python3

# Python3 Program to reverse a doubly linked list
 
# A node of the doubly linked list
 
class Node:
 
    # Constructor to create a new node
    def __init__(self, data):
        self.data = data
        self.next = None
        self.prev = None
 
 
class DoublyLinkedList:
     # Constructor for empty Doubly Linked List
    def __init__(self):
        self.head = None
 
    # Function reverse a Doubly Linked List
    def reverse(self):
        temp = None
        current = self.head
 
        # Swap next and prev for all nodes of
        # doubly linked list
        while current is not None:
            temp = current.prev
            current.prev = current.next
            current.next = temp
            current = current.prev
 
        # Before changing head, check for the cases like
        # empty list and list with only one node
        if temp is not None:
            self.head = temp.prev
 
    # Given a reference to the head of a list and an
    # integer,inserts a new node on the front of list
    def push(self, new_data):
 
        # 1. Allocates node
        # 2. Put the data in it
        new_node = Node(new_data)
 
        # 3. Make next of new node as head and
        # previous as None (already None)
        new_node.next = self.head
 
        # 4. change prev of head node to new_node
        if self.head is not None:
            self.head.prev = new_node
 
        # 5. move the head to point to the new node
        self.head = new_node
 
    def printList(self, node):
        while(node is not None):
            print(node.data, end=' ')
            node = node.next
 
 
# Driver's code
if __name__ == "__main__":
    dll = DoublyLinkedList()
    dll.push(2)
    dll.push(4)
    dll.push(8)
    dll.push(10)
 
    print("\nOriginal Linked List")
    dll.printList(dll.head)
 
    # Function call
    dll.reverse()
 
    print("\nReversed Linked List")
    dll.printList(dll.head)
 
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)

                    

C#

// A C# program to reverse a doubly linked list
 
using System;
 
public class LinkedList {
 
    static Node head;
 
    class Node {
 
        public int data;
        public Node next, prev;
 
        public Node(int d)
        {
            data = d;
            next = prev = null;
        }
    }
 
    /* Function to reverse a Doubly Linked List */
    void reverse()
    {
        Node temp = null;
        Node current = head;
 
        /* swap next and prev for all nodes of
        doubly linked list */
        while (current != null) {
            temp = current.prev;
            current.prev = current.next;
            current.next = temp;
            current = current.prev;
        }
 
        /* Before changing head, check for
          the cases like empty list and
         list with only one node */
        if (temp != null) {
            head = temp.prev;
        }
    }
 
    /* UTILITY FUNCTIONS */
    /* Function to insert a node at the
    beginning of the Doubly Linked List */
    void push(int new_data)
    {
 
        /* allocate node */
        Node new_node = new Node(new_data);
 
        /* 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;
 
        /* change prev of head node to new node */
        if (head != null) {
            head.prev = new_node;
        }
 
        /* move the head to point to the new node */
        head = new_node;
    }
 
    /* Function to print nodes in a given
    doubly linked list This function is
    same as printList() of singly linked list */
    void printList(Node node)
    {
        while (node != null) {
            Console.Write(node.data + " ");
            node = node.next;
        }
    }
 
    // Driver's code
    public static void Main(String[] args)
    {
        LinkedList list = new LinkedList();
 
        /* Let us create a sorted linked list
        to test the functions Created linked
        list will be 10->8->4->2 */
        list.push(2);
        list.push(4);
        list.push(8);
        list.push(10);
 
        Console.WriteLine("Original linked list ");
        list.printList(head);
         
          // Function call
        list.reverse();
        Console.WriteLine("");
        Console.WriteLine("The reversed Linked List is ");
        list.printList(head);
    }
}
 
// This code is contributed by 29AjayKumar

                    

Javascript

// javascript program to reverse a doubly linked list
 
var head;
 
     class Node {
            constructor(val) {
                this.data = val;
                this.prev = null;
                this.next = null;
            }
        }
    /* Function to reverse a Doubly Linked List */
    function reverse() {
var temp = null;
var current = head;
 
        /*
         * swap next and prev for all nodes of doubly linked list
         */
        while (current != null) {
            temp = current.prev;
            current.prev = current.next;
            current.next = temp;
            current = current.prev;
        }
 
        /*
         * Before changing head, check for the cases like empty list and list with only
         * one node
         */
        if (temp != null) {
            head = temp.prev;
        }
    }
 
    /* UTILITY FUNCTIONS */
    /*
     * Function to insert a node at the beginning of the Doubly Linked List
     */
    function push(new_data) {
        /* allocate node */
var new_node = new Node(new_data);
 
        /*
         * 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;
 
        /* change prev of head node to new node */
        if (head != null) {
            head.prev = new_node;
        }
 
        /* move the head to point to the new node */
        head = new_node;
    }
 
    /*
     * Function to print nodes in a given doubly linked list This function is same
     * as printList() of singly linked list
     */
    function printList(node) {
        while (node != null) {
            document.write(node.data + " ");
            node = node.next;
        }
    }
 
     
 
        /*
         * Let us create a sorted linked list to test the functions Created linked list
         * will be 10->8->4->2
         */
        push(2);
        push(4);
        push(8);
        push(10);
 
        document.write("Original linked list <br/>");
        printList(head);
 
        reverse();
        document.write("<br/>");
        document.write("The reversed Linked List is <br/>");
        printList(head);
 
// This code contributed by gauravrajput1

                    

Output
 Original Linked list 10 8 4 2 
 Reversed Linked list 2 4 8 10 

Time Complexity: O(N), where N denotes the number of nodes in the doubly linked list.
Auxiliary Space: O(1)

We can also swap data instead of pointers to reverse the Doubly Linked List. Method used for reversing array can be used to swap data. Swapping data can be costly compared to pointers if the size of the data item(s) is more.

Reverse a Doubly Linked List using Stack:

Push the node’s data into the stack while traversing the doubly linked list, then pop out the elements from the stack and copy the value to the nodes of the linked list by again traversing it

Follow the given steps to solve the problem using the above approach:

  • Traverse the whole Linked List and  Keep pushing the node’s data into the stack
  • Then keep popping the elements out of the stack and updating the Doubly Linked List

Below is the implementation of the above approach:

C++

// C++ program to reverse a doubly linked list
#include <bits/stdc++.h>
using namespace std;
struct LinkedList {
    struct Node {
        int data;
        Node *next, *prev;
        Node(int d)
        {
            data = d;
            next = prev = NULL;
        }
    };
    Node* head = NULL;
 
    /* Function to reverse a Doubly Linked List using Stacks
     */
    void reverse()
    {
        stack<int> st;
        Node* temp = head;
        while (temp != NULL) {
            st.push(temp->data);
            temp = temp->next;
        }
 
        // added all the elements sequence wise in the
        // st
        temp = head;
        while (temp != NULL) {
            temp->data = st.top();
            st.pop();
            temp = temp->next;
        }
 
        // popped all the elements and the added in the
        // linked list,
        // which are in the reversed order->
    }
 
    /* UTILITY FUNCTIONS */
    /* Function to insert a node at the beginning of the
     * Doubly Linked List */
    void Push(int new_data)
    {
 
        /* allocate node */
        Node* new_node = new Node(new_data);
 
        /* 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;
 
        /* change prev of head node to new node */
        if (head != NULL) {
            head->prev = new_node;
        }
 
        /* move the head to point to the new node */
        head = new_node;
    }
 
    /* Function to print nodes in a given doubly linked list
     This function is same as printList() of singly linked
     list */
    void printList(Node* node)
    {
        while (node) {
            cout << node->data << " ";
            node = node->next;
        }
    }
};
 
// Driver Code
int main()
{
    LinkedList list;
 
    /* Let us create a sorted linked list to test the
     functions Created linked list will be 10->8->4->2
   */
    list.Push(2);
    list.Push(4);
    list.Push(8);
    list.Push(10);
    cout << "Original linked list " << endl;
    list.printList(list.head);
    list.reverse();
    cout << endl;
    cout << "The reversed Linked List is " << endl;
    list.printList(list.head);
}
 
// This code is contributed by Pratham76

                    

Java

// Java program to reverse a doubly linked list
import java.util.*;
class LinkedList {
 
    static Node head;
 
    static class Node {
 
        int data;
        Node next, prev;
 
        Node(int d)
        {
            data = d;
            next = prev = null;
        }
    }
 
    /* Function to reverse a Doubly Linked List using Stacks
     */
    void reverse()
    {
        Stack<Integer> stack = new Stack<>();
        Node temp = head;
        while (temp != null) {
            stack.push(temp.data);
            temp = temp.next;
        }
        // added all the elements sequence wise in the
        // stack
        temp = head;
        while (temp != null) {
            temp.data = stack.pop();
            temp = temp.next;
        }
        // popped all the elements and the added in the
        // linked list,
        // which are in the reversed order.
    }
 
    /* UTILITY FUNCTIONS */
    /* Function to insert a node at the beginning of the
     * Doubly Linked List */
    void push(int new_data)
    {
        /* allocate node */
        Node new_node = new Node(new_data);
 
        /* 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;
 
        /* change prev of head node to new node */
        if (head != null) {
            head.prev = new_node;
        }
 
        /* move the head to point to the new node */
        head = new_node;
    }
 
    /* Function to print nodes in a given doubly linked list
     This function is same as printList() of singly 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();
 
        /* Let us create a sorted linked list to test the
         functions Created linked list will be 10->8->4->2
       */
        list.push(2);
        list.push(4);
        list.push(8);
        list.push(10);
 
        System.out.println("Original linked list ");
        list.printList(head);
 
        list.reverse();
        System.out.println("");
        System.out.println("The reversed Linked List is ");
        list.printList(head);
    }
}
 
// This code has been contributed by Rashita Mehta

                    

Python3

# Python3 code for the above approach
 
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.prev = None
 
 
class DoublyLinkedList:
    def __init__(self):
        self.head = None
 
    """
    method to reverse a Doubly-Linked List using Stacks
    """
 
    def reverseUsingStacks(self):
 
        stack = []
        temp = self.head
        while temp is not None:
            stack.append(temp.data)
            temp = temp.next
 
        # Add all the elements in the stack
        # in a sequence to the stack
        temp = self.head
        while temp is not None:
            temp.data = stack.pop()
            temp = temp.next
 
        # Popped all the elements and the
        # added in the linked list,
        # in a reversed order.
 
    """
    method to push a new item before the head
    """
 
    def push(self, new_data):
        new_node = Node(new_data)
        new_node.next = self.head
 
        if self.head is not None:
            self.head.prev = new_node
 
        self.head = new_node
 
    """
    method to traverse the doubly-linked
    list and print every node in the list
    """
 
    def printList(self, node):
        while(node is not None):
            print(node.data)
            node = node. next
 
 
# driver's code
if __name__ == "__main__":
    dll = DoublyLinkedList()
    dll.push(2)
    dll.push(4)
    dll.push(8)
    dll.push(10)
 
    print("original doubly-linked list")
    dll.printList(dll.head)
 
    # Function call
    dll.reverseUsingStacks()
 
    print(" reversed doubly-linked list")
    dll.printList(dll.head)

                    

C#

// C# program to reverse a doubly linked list
 
using System;
using System.Collections;
using System.Collections.Generic;
class LinkedList {
    public static Node head;
    public class Node {
        public int data;
        public Node next, prev;
        public Node(int d)
        {
            data = d;
            next = prev = null;
        }
    }
 
    /* Function to reverse a Doubly Linked List using Stacks
     */
    public void reverse()
    {
        Stack stack = new Stack();
        Node temp = head;
        while (temp != null) {
            stack.Push(temp.data);
            temp = temp.next;
        }
 
        // added all the elements sequence wise in the
        // stack
        temp = head;
        while (temp != null) {
            temp.data = (int)stack.Pop();
            temp = temp.next;
        }
 
        // popped all the elements and the added in the
        // linked list,
        // which are in the reversed order.
    }
 
    /* UTILITY FUNCTIONS */
    /* Function to insert a node at the beginning of the
     * Doubly Linked List */
    public void Push(int new_data)
    {
 
        /* allocate node */
        Node new_node = new Node(new_data);
 
        /* 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;
 
        /* change prev of head node to new node */
        if (head != null) {
            head.prev = new_node;
        }
 
        /* move the head to point to the new node */
        head = new_node;
    }
 
    /* Function to print nodes in a given doubly linked list
     This function is same as printList() of singly linked
     list */
    public void printList(Node node)
    {
        while (node != null) {
            Console.Write(node.data + " ");
            node = node.next;
        }
    }
 
    // Driver's Code
    public static void Main(string[] args)
    {
        LinkedList list = new LinkedList();
 
        /* Let us create a sorted linked list to test the
         functions Created linked list will be 10->8->4->2
       */
        list.Push(2);
        list.Push(4);
        list.Push(8);
        list.Push(10);
        Console.WriteLine("Original linked list ");
        list.printList(head);
           
          // Function call
        list.reverse();
        Console.WriteLine("");
        Console.WriteLine("The reversed Linked List is ");
        list.printList(head);
    }
}
 
// This code is contributed by rutvik_56

                    

Javascript

// Javascript program to reverse a doubly linked list
class Node
{
    constructor(d)
    {
        this.data = d;
        this.next = this.prev = null;
    }
}
 
let head;
 
// Function to reverse a Doubly
// Linked List using Stacks
function reverse()
{
    let stack = [];
    let temp = head;
     
    while (temp != null)
    {
        stack.push(temp.data);
        temp = temp.next;
    }
     
    // Added all the elements sequence
    // wise in the stack
    temp = head;
     
    while (temp != null)
    {
        temp.data = stack.pop();
        temp = temp.next;
    }
     
    // Popped all the elements and the
    // added in the linked list,
    // which are in the reversed order.
}
 
// UTILITY FUNCTIONS
// Function to insert a node at the
// beginning of the Doubly Linked List
function push(new_data)
{
     
    /* Allocate node */
    let new_node = new Node(new_data);
 
    /* 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;
 
    /* Change prev of head node to new node */
    if (head != null) {
        head.prev = new_node;
    }
 
    /* Move the head to point to the new node */
    head = new_node;
}
 
// Function to print nodes in a given
// doubly linked list. This function
// is same as printList() of singly
// linked list
function printList(node)
{
    while (node != null)
    {
        document.write(node.data + " ");
        node = node.next;
    }
}
 
// Driver Code
 
// Let us create a sorted linked list
// to test the functions Created linked
// list will be 10->8->4->2
push(2);
push(4);
push(8);
push(10);
 
document.write("Original linked list <br>");
printList(head);
 
reverse();
document.write("<br>");
document.write("The reversed Linked List is <br>");
printList(head);
 
// This code is contributed by rag2127

                    

Output
Original linked list 
10 8 4 2 
The reversed Linked List is 
2 4 8 10 

Time Complexity: O(N)
Auxiliary Space: O(N)

To reverse a doubly linked list, we can follow the below algorithm:

Check if the head of the linked list is null or the next node is null. If yes, return the head of the list.
Initialize three pointers – current pointing to the head of the list, prev to null and next to null.
Traverse the linked list by moving the current pointer to the next node, and for each node, set its next pointer to point to the previous node and its prev pointer to point to the next node.
Once the traversal is complete, set the head of the list to point to the last node of the original linked list (which is now the first node of the reversed list).
Return the new head of the list.

Algorithmic Steps:
 

Step 1 : Create a function to reverse the linked list, which takes the head node as input.

step 2 : Initialize three pointers: prevNode to NULL, currentNode to the head node, and nextNode to NULL.

Step 3  : Traverse the linked list using a while loop until the currentNode pointer is not NULL.

Step 4 : Inside the loop, assign nextNode as the next node of the currentNode using the next pointer.

Step 5 : Set the next pointer of the currentNode to prevNode, effectively reversing the pointer direction of the currentNode.

Step 6 : Update prevNode to the currentNode.

Step 7 : Update currentNode to the nextNode.

Step 8 :Finally, set the head node to prevNode and return it.

In this algorithm, we first check if the linked list is empty or has only one node. If yes, we return the head of the list. Then we initialize three pointers – current, prev and next – to null, the head of the list and null, respectively. Then, we traverse the linked list, setting the next and prev pointers of each node to point to the previous and next nodes, respectively. Finally, we set the head of the list to the last node of the original linked list (which is now the first node of the reversed list) and return the new head.

C++

#include <iostream>
 
struct Node {
    int data;
    Node* prev;
    Node* next;
};
 
void reverse(Node** head_ref) {
    Node* current = *head_ref;
    Node* temp = NULL;
 
    while (current != NULL) {
        temp = current->prev;
        current->prev = current->next;
        current->next = temp;
        current = current->prev;
    }
 
    if (temp != NULL) {
        *head_ref = temp->prev;
    }
}
 
void printList(Node* node) {
    while (node != NULL) {
        std::cout << node->data << " ";
        node = node->next;
    }
}
 
int main() {
    Node* head = NULL;
    Node* second = NULL;
    Node* third = NULL;
 
    // allocate nodes
    head = new Node();
    second = new Node();
    third = new Node();
 
    // link nodes
    head->data = 1;
    head->prev = NULL;
    head->next = second;
 
    second->data = 2;
    second->prev = head;
    second->next = third;
 
    third->data = 3;
    third->prev = second;
    third->next = NULL;
 
    std::cout << "Original List: ";
    printList(head);
 
    reverse(&head);
 
    std::cout << "\nReversed List: ";
    printList(head);
 
    return 0;
}

                    

Java

class Node {
    int data;
    Node prev;
    Node next;
}
 
class Main {
    static void reverse(Node[] head_ref)
    {
        Node current = head_ref[0];
        Node temp = null;
         
        while (current != null) {
            temp = current.prev;
            current.prev = current.next;
            current.next = temp;
            current = current.prev;
        }
     
        if (temp != null) {
            head_ref[0] = temp.prev;
        }
    }
     
    static void printList(Node node) {
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }
    }
     
    public static void main(String[] args)
    {
        Node head = null;
        Node second = null;
        Node third = null;
     
        // allocate nodes
        head = new Node();
        second = new Node();
        third = new Node();
     
        // link nodes
        head.data = 1;
        head.prev = null;
        head.next = second;
     
        second.data = 2;
        second.prev = head;
        second.next = third;
     
        third.data = 3;
        third.prev = second;
        third.next = null;
     
        System.out.print("Original List: ");
        printList(head);
     
        Node[] head_ref = new Node[1];
        head_ref[0] = head;
        reverse(head_ref);
        head = head_ref[0];
     
        System.out.print("\nReversed List: ");
        printList(head);
    }
}

                    

Python3

# Define Node class
class Node:
    def __init__(self):
        self.data = 0
        self.prev = None
        self.next = None
 
# Define function to reverse the doubly linked list
 
 
def reverse(head_ref):
    current = head_ref
    temp = None
 
    while current != None:
        temp = current.prev
        current.prev = current.next
        current.next = temp
        current = current.prev
 
    if temp != None:
        head_ref = temp.prev
 
    return head_ref
 
# Define function to print the doubly linked list
 
 
def printList(node):
    while node != None:
        print(node.data, end=" ")
        node = node.next
 
 
# Create nodes
head = Node()
second = Node()
third = Node()
 
# Link nodes
head.data = 1
head.prev = None
head.next = second
 
second.data = 2
second.prev = head
second.next = third
 
third.data = 3
third.prev = second
third.next = None
 
# Print original list
print("Original List: ", end="")
printList(head)
 
# Reverse the list
head = reverse(head)
 
# Print the reversed list
print("\nReversed List: ", end="")
printList(head)

                    

C#

using System;
 
public class Node {
  public int data;
  public Node prev;
  public Node next;
}
 
public class Program {
  static void reverse(ref Node head) {
    Node current = head;
    Node temp = null;
 
    while (current != null) {
      temp = current.prev;
      current.prev = current.next;
      current.next = temp;
      current = current.prev;
    }
 
    if (temp != null) {
      head = temp.prev;
    }
  }
 
  static void printList(Node node) {
    while (node != null) {
      Console.Write(node.data + " ");
      node = node.next;
    }
  }
 
  public static void Main(string[] args) {
    Node head = null;
    Node second = null;
    Node third = null;
 
    // allocate nodes
    head = new Node();
    second = new Node();
    third = new Node();
 
    // link nodes
    head.data = 1;
    head.prev = null;
    head.next = second;
 
    second.data = 2;
    second.prev = head;
    second.next = third;
 
    third.data = 3;
    third.prev = second;
    third.next = null;
 
    Console.Write("Original List: ");
    printList(head);
 
    reverse(ref head);
 
    Console.Write("\nReversed List: ");
    printList(head);
  }
}

                    

Javascript

class Node {
    constructor() {
        this.data = 0;
        this.prev = null;
        this.next = null;
    }
}
 
function reverse(head_ref) {
    let current = head_ref;
    let temp = null;
 
    while (current != null) {
        temp = current.prev;
        current.prev = current.next;
        current.next = temp;
        current = current.prev;
    }
 
    if (temp != null) {
        head_ref = temp.prev;
    }
 
    return head_ref;
}
 
function printList(node) {
    while (node != null) {
        console.log(node.data + " ");
        node = node.next;
    }
}
 
let head = new Node();
let second = new Node();
let third = new Node();
 
head.data = 1;
head.prev = null;
head.next = second;
 
second.data = 2;
second.prev = head;
second.next = third;
 
third.data = 3;
third.prev = second;
third.next = null;
 
// Print original list
console.log("Original List: ")
printList(head)
 
// Reverse the list
head = reverse(head)
 
// Print the reversed list
console.log("\nReversed List: ")
printList(head)

                    

Output
Original List: 1 2 3 
Reversed List: 3 2 1 

Time and Space complexities:

reverse(Node** head_ref): This function reverses the doubly linked list. The time complexity of this function is O(n), where n is the number of nodes in the list. This is because the function visits each node once and performs a constant amount of work on each node. The space complexity of this function is O(1), as it uses a constant amount of extra memory regardless of the size of the input.

printList(Node* node): This function prints the contents of the doubly linked list. The time complexity of this function is O(n), where n is the number of nodes in the list. This is because the function visits each node once and performs a constant amount of work on each node. The space complexity of this function is O(1), as it uses a constant amount of extra memory regardless of the size of the input.

main(): This function creates a doubly linked list and then reverses it using the reverse() function. The time complexity of this function is O(n), where n is the number of nodes in the list. This is because the function calls the reverse() function, which has a time complexity of O(n), and also calls the printList() function twice, each of which has a time complexity of O(n). The space complexity of this function is O(n), as it creates a doubly linked list with n nodes and uses a constant amount of extra memory for the pointers head, second, and third.



Last Updated : 30 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads