Open In App
Related Articles

Print Doubly Linked list in Reverse Order

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

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 <bits/stdc++.h>
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

<script>
  
      // JavaScript Program to print doubly
      // linked list in reverse order
      // Doubly linked list node
      class Node {
        constructor() {
          this.data = 0;
          this.next = null;
          this.prev = null;
        }
      }
  
      // Function to print nodes of Doubly
      // Linked List in reverse order
      function reversePrint(head_ref) {
        var 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) {
          document.write(tail.data + " ");
          tail = tail.prev;
        }
        document.write(tail.data + "<br>");
      }
  
      // UTILITY FUNCTIONS /
      // Function to insert a node at the
      // beginning of the Doubly Linked List
      function push(head_ref, new_data) {
        // allocate node
        var 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
      // Start with the empty list
      var 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);
  
      document.write("Linked List elements in reverse order : <br>");
  
      reversePrint(head);
        
    </script>

                    

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)


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