Python program to create a doubly linked list of n nodes and display it in reverse order

Traverse through the list by swapping the previous pointer with next pointer of each node. Then, swap the position of head and tail node that is, head of the original list will become tail of new list and tail of the original list will become head of the new list. So, the reversed list will be:

python program to create a doubly linked list of n nodes and display it in reverse order

ALGORITHM:

Define a Node class which represents a node in the list. It will have three properties: data, previous which will point to the previous node and next which will point to the next node.
Define another class for creating a doubly linked list, and it has two nodes: head and tail. Initially, head and tail will point to null.
addNode() will add node to the list:

It first checks whether the head is null, then it will insert the node as the head.
Both head and tail will point to a newly added node.
Head's previous pointer will point to null and tail's next pointer will point to null.
If the head is not null, the new node will be inserted at the end of the list such that new node's previous pointer will point to tail.
The new node will become the new tail. Tail's next pointer will point to null.

a. reverse() will reverse the given doubly linked list.

Define a node current which will initially point to head.
Traverse through the list by making current to point to current.next in each iteration till current points to null.
In each iteration, swap previous and next pointer of each node to reverse the direction of the list.
In the end, swap the position of head and tail.

a. display() will show all the nodes present in the list.

Define a new node 'current' that will point to the head.
Print current.data till current points to null.
Current will point to the next node in the list in each iteration.

PROGRAM:

#Represent a node of doubly linked list  
class Node:  
    def __init__(self,data):  
        self.data = data;  
        self.previous = None;  
        self.next = None;  
          
class ReverseList:  
    #Represent the head and tail of the doubly linked list  
    def __init__(self):  
        self.head = None;  
        self.tail = None;  
          
    #addNode() will add a node to the list  
    def addNode(self, data):  
        #Create a new node  
        newNode = Node(data);  
          
        #If list is empty  
        if(self.head == None):  
            #Both head and tail will point to newNode  
            self.head = self.tail = newNode;  
            #head's previous will point to None  
            self.head.previous = None;  
            #tail's next will point to None, as it is the last node of the list  
            self.tail.next = None;  
        else:  
            #newNode will be added after tail such that tail's next will point to newNode  
            self.tail.next = newNode;  
            #newNode's previous will point to tail  
            newNode.previous = self.tail;  
            #newNode will become new tail  
            self.tail = newNode;  
            #As it is last node, tail's next will point to None  
            self.tail.next = None;  
              
    #reverse() will reverse the doubly linked list  
    def reverse(self):  
        #Node current will point to head  
        current = self.head;  
          
        #Swap the previous and next pointers of each node to reverse the direction of the list  
        while(current != None):  
            temp = current.next;  
            current.next = current.previous;  
            current.previous = temp;  
            current = current.previous;  
        #Swap the head and tail pointers.  
        temp = self.head;  
        self.head = self.tail;  
        self.tail = temp;  
          
    #display() will print out the elements of the list  
    def display(self):  
        #Node current will point to head  
        current = self.head;  
        if(self.head == None):  
            print("List is empty");  
            return;  
              
        while(current != None):  
            #Prints each node by incrementing pointer.  
            print(current.data),  
            current = current.next;  
              
dList = ReverseList();  
#Add nodes to the list  
dList.addNode(1);  
dList.addNode(2);  
dList.addNode(3);  
dList.addNode(4);  
dList.addNode(5);  
   
print("Original List: ");  
dList.display();  
   
#Reverse the given list  
dList.reverse();  
   
#Displays the reversed list  
print("\nReversed List: ");  
dList.display();  

Output:

Original List: 
1 2 3 4 5 
Reversed List: 
5 4 3 2 1

Next TopicPython Programs

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

^{Like/Subscribe us for latest updates or newsletter}

Python Tutorial

Python OOPs

Python MySQL

Python MongoDB

Python SQLite

Python Questions

Plotly

Python Tkinter (GUI)

Python Web Blocker

Python MCQ

Related Tutorials

Python Programs

4. Python program to create a doubly linked list of n nodes and display it in reverse order.