Python program to create a Circular Linked List of n nodes and display it in reverse order
In this program, we create a circular linked list, then traverse the list in the reverse order and print the nodes.
ALGORITHM:
- Define a Node class which represents a node in the list. It has two properties data and next which will point to the next node.
- Define another class for creating the circular linked list, and it has two nodes: head and tail. It has two methods: add(), display() and reverse().
- add() will add a 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 the newly added node.
- If the head is not null, the new node will be the new tail, and new tail will point to head as it is a circular linked list.
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 will points to head again.
- Current will point to the next node in the list in each iteration.
a. reverse() will print the circular linked list in reverse order.
- This method checks whether the next node to current is head which implies that, current is pointing to tail, then it will print the data of the tail node.
- Recursively call reverse() by considering node next to current node and prints out all the nodes in reverse order starting from the tail.
PROGRAM:
- #Represents the node of list.
- class Node:
- def __init__(self,data):
- self.data = data;
- self.next = None;
- class CreateList:
- #Declaring head and tail pointer as null.
- def __init__(self):
- self.head = Node(None);
- self.tail = Node(None);
- self.head.next = self.tail;
- self.tail.next = self.head;
- #This function will add the new node at the end of the list.
- def add(self,data):
- newNode = Node(data);
- #Checks if the list is empty.
- if self.head.data is None:
- #If list is empty, both head and tail would point to new node.
- self.head = newNode;
- self.tail = newNode;
- newNode.next = self.head;
- else:
- #tail will point to new node.
- self.tail.next = newNode;
- #New node will become new tail.
- self.tail = newNode;
- #Since, it is circular linked list tail will point to head.
- self.tail.next = self.head;
- #Displays all the nodes in the list
- def display(self):
- current = self.head;
- if self.head is None:
- print(“List is empty”);
- return;
- else:
- #Prints each node by incrementing pointer.
- print(current.data),
- while(current.next != self.head):
- current = current.next;
- print(current.data),
- #Reverse the order of the nodes present in the list.
- def reverse(self, current):
- #Checks if the next node is head, if yes then prints it.
- if(current.next == self.head):
- print(current.data),
- return;
- #Recursively calls the reverse function
- self.reverse(current.next);
- print(current.data),
- class CircularLinkedList:
- cl = CreateList();
- #Adds data to the list
- cl.add(1);
- cl.add(2);
- cl.add(3);
- cl.add(4);
- cl.add(5);
- cl.add(6);
- print(“Original List: “);
- cl.display();
- print(“\nReversed List: “);
- #Print reversed list
- cl.reverse(cl.head);
Output:
Original List: 1 2 3 4 5 6 Reversed List: 6 5 4 3 2 1