# Print Doubly Linked list in Reverse Order

Given a doubly-linked list of positive integers. The task is to print the given doubly linked list data in reverse order.

Examples:

```Input: List = 1 <=> 2 <=>  3 <=>  4 <=>  5
Output: 5  4  3  2  1

Input: 10 <=> 20 <=> 30 <=> 40
Output: 40  30  20  10```

Approach:

• Take a pointer to point to head of the doubly linked list.
• Now, start traversing through the linked list till the end.
• After reaching last node, start traversing in backward direction and simultaneously print the node->data.

Below is the implementation of the above approach:

## C++

 `// C++ Program to print doubly  ``// linked list in reverse order  ``#include ``using` `namespace` `std; `` ` `// Doubly linked list node ``struct` `Node { ``    ``int` `data; ``    ``struct` `Node* next; ``    ``struct` `Node* prev; ``}; `` ` `// Function to print nodes of Doubly  ``// Linked List in reverse order  ``void` `reversePrint(``struct` `Node** head_ref) ``{ ``    ``struct` `Node* tail = *head_ref; `` ` `    ``// Traversing till tail of the linked list ``    ``while` `(tail->next != NULL) { ``        ``tail = tail->next; ``    ``} `` ` `    ``// Traversing linked list from tail ``    ``// and printing the node->data ``    ``while` `(tail != *head_ref) { ``        ``cout << tail->data << ``" "``; ``        ``tail = tail->prev; ``    ``} ``    ``cout << tail->data << endl; ``} `` ` `/* 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; ``} `` ` `// Driver 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); `` ` `    ``cout << ``"Linked List elements in reverse order : "` `<< endl; `` ` `    ``reversePrint(&head); `` ` `    ``return` `0; ``} `

## Java

 `// Java Program to print doubly  ``// linked list in reverse order  ``public` `class` `Sol ``{ `` ` `// Doubly linked list node  ``static` `class` `Node ``{  ``    ``int` `data;  ``    ``Node next;  ``    ``Node prev;  ``};  `` ` `// Function to print nodes of Doubly  ``// Linked List in reverse order  ``static` `void` `reversePrint( Node head_ref)  ``{  ``    ``Node tail = head_ref;  `` ` `    ``// Traversing till tail of the linked list  ``    ``while` `(tail.next != ``null``) ``    ``{  ``        ``tail = tail.next;  ``    ``}  `` ` `    ``// Traversing linked list from tail  ``    ``// and printing the node.data  ``    ``while` `(tail != head_ref) ``    ``{  ``        ``System.out.print( tail.data + ``" "``);  ``        ``tail = tail.prev;  ``    ``}  ``    ``System.out.println( tail.data );  ``}  `` ` `// UTILITY FUNCTIONS / ``// Function to insert a node at the  ``// beginning of the Doubly Linked List  ``static` `Node 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;  ``    ``return` `head_ref; ``}  `` ` `// Driver Code  ``public` `static` `void` `main(String args[]) ``{  ``    ``// 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  ``    ``head = push(head, ``2``);  ``    ``head = push(head, ``4``);  ``    ``head = push(head, ``8``);  ``    ``head = push(head, ``10``);  `` ` `    ``System.out.print( ``"Linked List elements in reverse order : "` `);  `` ` `    ``reversePrint(head);  ``}  ``} `` ` `// This code is contributed by Arnab Kundu  `

## Python3

 `class` `node: ``    ``def` `__init__(``self``,data``=``0``): ``        ``self``.data``=``0``        ``self``.``next``=``0``        ``self``.prev``=``0``class` `DLL(): ``    ``def` `__init__(``self``): ``        ``# Initialize Node ``        ``self``.head``=``node() ``         ` `    ``def` `create(``self``,data): ``        ``if` `self``.head.data ``is` `0``: ``             ` `            ``self``.head.data``=``data ``            ``self``.head.``next``=``0``            ``self``.head.prev``=``0``        ``elif` `self``.head.``next` `is` `0``: ``             ` `            ``newnode``=``node() ``            ``self``.head.``next``=``newnode ``            ``newnode.prev``=``self``.head ``            ``newnode.data``=``data ``            ``newnode.``next``=``0``        ``else``: ``            ``newnode``=``node() ``            ``curr``=``self``.head ``            ``while` `curr.``next``: ``                ``curr``=``curr.``next``            ``curr.``next``=``newnode ``            ``newnode.prev``=``curr ``            ``newnode.data``=``data ``            ``newnode.``next``=``0``     ` `         ` `    ``def` `back(``self``): ``        ``cursor ``=` `self``.head ``        ``while` `cursor!``=``0``: ``            ``copy``=``cursor ``            ``cursor ``=` `cursor.``next``        ``print``(``"Reverse of Doubly Linked list:-"``) ``        ``while` `copy!``=``self``.head.prev: ``            ``print``(copy.data) ``            ``copy``=``copy.prev ``             ` `    ``def` `printlist(``self``): ``        ``cursor ``=` `self``.head ``        ``while` `cursor!``=``0``: ``            ``print``(cursor.data) ``            ``cursor ``=` `cursor.``next``                 ` `                 ` `ll``=``DLL() ``ll.create(``2``) ``ll.create(``4``) ``ll.create(``8``)                ``ll.create(``10``) `` ` `#ll.printlist() ``ll.back() ``         ` `        `

## C#

 `// C# Program to print doubly  ``// linked list in reverse order ``using` `System;      ``     ` `class` `Sol ``{ `` ` `// Doubly linked list node  ``public` `class` `Node ``{  ``    ``public` `int` `data;  ``    ``public` `Node next;  ``    ``public` `Node prev;  ``};  `` ` `// Function to print nodes of Doubly  ``// Linked List in reverse order  ``static` `void` `reversePrint( Node head_ref)  ``{  ``    ``Node tail = head_ref;  `` ` `    ``// Traversing till tail of the linked list  ``    ``while` `(tail.next != ``null``) ``    ``{  ``        ``tail = tail.next;  ``    ``}  `` ` `    ``// Traversing linked list from tail  ``    ``// and printing the node.data  ``    ``while` `(tail != head_ref) ``    ``{  ``        ``Console.Write( tail.data + ``" "``);  ``        ``tail = tail.prev;  ``    ``}  ``    ``Console.WriteLine( tail.data );  ``}  `` ` `// UTILITY FUNCTIONS / ``// Function to insert a node at the  ``// beginning of the Doubly Linked List  ``static` `Node 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;  ``    ``return` `head_ref; ``}  `` ` `// Driver Code  ``public` `static` `void` `Main(String []args) ``{  ``    ``// 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  ``    ``head = push(head, 2);  ``    ``head = push(head, 4);  ``    ``head = push(head, 8);  ``    ``head = push(head, 10);  `` ` `    ``Console.Write( ``"Linked List elements in reverse order : "` `);  `` ` `    ``reversePrint(head);  ``}  ``} `` ` `// This code contributed by Rajput-Ji `

## Javascript

 ``

Output
```Linked List elements in reverse order :
2 4 8 10```

Complexity Analysis:

• Time complexity: O(N) where N is no of nodes in Doubly Linked List
• Auxiliary Space: O(N)

Previous
Next