# Reverse a Doubly Linked List

• Difficulty Level : Easy
• Last Updated : 24 Mar, 2023

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 ``#include ` `/* 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 ``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
"``);``        ``printList(head);` `        ``reverse();``        ``document.write(``"
"``);``        ``document.write(``"The reversed Linked List is
"``);``        ``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 ``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 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
"``);``printList(head);` `reverse();``document.write(``"
"``);``document.write(``"The reversed Linked List is
"``);``printList(head);` `// This code is contributed by rag2127`

Output

```Original linked list
10 8 4 2
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 ` `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)`

## 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.

My Personal Notes arrow_drop_up