Circular Singly Linked List - Reverse the List
While working with a circular singly linked list, sometimes it is required to reverse it. Reversing a List produces following result: if the given List is 10->20->30->40->50, after reversing the List the List becomes 50->40->30->20->10.
Reversing a List requires creating three nodes, considering that the list is not empty, which are as follows: tempNode pointing to head, prevNode pointing to head and curNode pointing to next of head. Then make next of prevNode as itself to make the first node as last node of the reversed list. After that, while the curNode is not head adjust links (unlink curNode and link it to the reversed list from front and modify curNode and prevNode to the next element in the list). At last, make the prevNode (last node) as head.
The function reverseList is created for this purpose. It is a 4-step process.
void reverseList() { //1. If head is not null create three nodes // prevNode - pointing to head, // tempNode - pointing to head, // curNode - pointing to next of head if(head != NULL) { Node* prevNode = head; Node* tempNode = head; Node* curNode = head->next; //2. assign next of prevNode as itself to make the // first node as last node of the reversed list prevNode->next = prevNode; while(curNode != head) { //3. While the curNode is not head adjust links // (unlink curNode and link it to the reversed list // from front and modify curNode and prevNode) tempNode = curNode->next; curNode->next = prevNode; head->next = curNode; prevNode = curNode; curNode = tempNode; } //4. Make prevNode (last node) as head head = prevNode; } }
void reverseList(struct Node** head_ref) { //1. If head is not null create three nodes // prevNode - pointing to head, // tempNode - pointing to head, // curNode - pointing to next of head if(*head_ref != NULL) { struct Node* prevNode = *head_ref; struct Node* tempNode = *head_ref; struct Node* curNode = (*head_ref)->next; //2. assign next of prevNode as itself to make the // first node as last node of the reversed list prevNode->next = prevNode; while(curNode != *head_ref) { //3. While the curNode is not head adjust links // (unlink curNode and link it to the reversed list // from front and modify curNode and prevNode) tempNode = curNode->next; curNode->next = prevNode; (*head_ref)->next = curNode; prevNode = curNode; curNode = tempNode; } //4. Make prevNode (last node) as head *head_ref = prevNode; } }
def reverseList(self): #1. If head is not null create three nodes # prevNode - pointing to head, # tempNode - pointing to head, # curNode - pointing to next of head if(self.head != None): prevNode = self.head tempNode = self.head curNode = self.head.next #2. assign next of prevNode as itself to make the # first node as last node of the reversed list prevNode.next = prevNode while(curNode != self.head): #3. While the curNode is not head adjust links # (unlink curNode and link it to the reversed list # from front and modify curNode and prevNode) tempNode = curNode.next curNode.next = prevNode self.head.next = curNode prevNode = curNode curNode = tempNode #4. Make prevNode (last node) as head self.head = prevNode
void reverseList() { //1. If head is not null create three nodes // prevNode - pointing to head, // tempNode - pointing to head, // curNode - pointing to next of head if(this.head != null) { Node prevNode = this.head; Node tempNode = this.head; Node curNode = this.head.next; //2. assign next of prevNode as itself to make the // first node as last node of the reversed list prevNode.next = prevNode; while(curNode != this.head) { //3. While the curNode is not head adjust links // (unlink curNode and link it to the reversed list // from front and modify curNode and prevNode) tempNode = curNode.next; curNode.next = prevNode; this.head.next = curNode; prevNode = curNode; curNode = tempNode; } //4. Make prevNode (last node) as head this.head = prevNode; } }
public void reverseList() { //1. If head is not null create three nodes // prevNode - pointing to head, // tempNode - pointing to head, // curNode - pointing to next of head if(this.head != null) { Node prevNode = this.head; Node tempNode = this.head; Node curNode = this.head.next; //2. assign next of prevNode as itself to make the // first node as last node of the reversed list prevNode.next = prevNode; while(curNode != this.head) { //3. While the curNode is not head adjust links // (unlink curNode and link it to the reversed list // from front and modify curNode and prevNode) tempNode = curNode.next; curNode.next = prevNode; this.head.next = curNode; prevNode = curNode; curNode = tempNode; } //4. Make prevNode (last node) as head this.head = prevNode; } }
public function reverseList() { //1. If head is not null create three nodes // prevNode - pointing to head, // tempNode - pointing to head, // curNode - pointing to next of head if($this->head != null) { $prevNode = $this->head; $tempNode = $this->head; $curNode = $this->head->next; //2. assign next of prevNode as itself to make the // first node as last node of the reversed list $prevNode->next = $prevNode; while($curNode != $this->head) { //3. While the curNode is not head adjust links // (unlink curNode and link it to the reversed list // from front and modify curNode and prevNode) $tempNode = $curNode->next; $curNode->next = $prevNode; $this->head->next = $curNode; $prevNode = $curNode; $curNode = $tempNode; } //4. Make prevNode (last node) as head $this->head = $prevNode; } }
The below is a complete program that uses above discussed concept to reverse a given circular singly linked list.
#include <iostream> using namespace std; //node structure struct Node { int data; Node* next; }; class LinkedList { private: Node* head; public: LinkedList(){ head = NULL; } //Add new element at the end of the list void push_back(int newElement) { Node* newNode = new Node(); newNode->data = newElement; newNode->next = NULL; if(head == NULL) { head = newNode; newNode->next = head; } else { Node* temp = head; while(temp->next != head) temp = temp->next; temp->next = newNode; newNode->next = head; } } //reverse the list void reverseList() { if(head != NULL) { Node* prevNode = head; Node* tempNode = head; Node* curNode = head->next; prevNode->next = prevNode; while(curNode != head) { tempNode = curNode->next; curNode->next = prevNode; head->next = curNode; prevNode = curNode; curNode = tempNode; } head = prevNode; } } //display the content of the list void PrintList() { Node* temp = head; if(temp != NULL) { cout<<"The list contains: "; while(true) { cout<<temp->data<<" "; temp = temp->next; if(temp == head) break; } cout<<endl; } else { cout<<"The list is empty.\n"; } } }; // test the code int main() { LinkedList MyList; //Add five elements in the list. MyList.push_back(10); MyList.push_back(20); MyList.push_back(30); MyList.push_back(40); MyList.push_back(50); //Display the content of the list. MyList.PrintList(); //Reversing the list. MyList.reverseList(); //Display the content of the list. MyList.PrintList(); return 0; }
The above code will give the following output:
The list contains: 10 20 30 40 50 The list contains: 50 40 30 20 10
#include <stdio.h> #include <stdlib.h> //node structure struct Node { int data; struct Node* next; }; //Add new element at the end of the list void push_back(struct Node** head_ref, int newElement) { struct Node *newNode, *temp; newNode = (struct Node*)malloc(sizeof(struct Node)); newNode->data = newElement; newNode->next = NULL; if(*head_ref == NULL) { *head_ref = newNode; newNode->next = *head_ref; } else { temp = *head_ref; while(temp->next != *head_ref) { temp = temp->next; } temp->next = newNode; newNode->next = *head_ref; } } //reverse the list void reverseList(struct Node** head_ref) { if(*head_ref != NULL) { struct Node* prevNode = *head_ref; struct Node* tempNode = *head_ref; struct Node* curNode = (*head_ref)->next; prevNode->next = prevNode; while(curNode != *head_ref) { tempNode = curNode->next; curNode->next = prevNode; (*head_ref)->next = curNode; prevNode = curNode; curNode = tempNode; } *head_ref = prevNode; } } //display the content of the list void PrintList(struct Node* head_ref) { struct Node* temp = head_ref; if(head_ref != NULL) { printf("The list contains: "); while (1) { printf("%i ",temp->data); temp = temp->next; if(temp == head_ref) break; } printf("\n"); } else { printf("The list is empty.\n"); } } // test the code int main() { struct Node* MyList = NULL; //Add five elements in the list. push_back(&MyList, 10); push_back(&MyList, 20); push_back(&MyList, 30); push_back(&MyList, 40); push_back(&MyList, 50); //Display the content of the list. PrintList(MyList); //Reversing the list. reverseList(&MyList); //Display the content of the list. PrintList(MyList); return 0; }
The above code will give the following output:
The list contains: 10 20 30 40 50 The list contains: 50 40 30 20 10
# node structure class Node: def __init__(self, data): self.data = data self.next = None #class Linked List class LinkedList: def __init__(self): self.head = None #Add new element at the end of the list def push_back(self, newElement): newNode = Node(newElement) if(self.head == None): self.head = newNode newNode.next = self.head return else: temp = self.head while(temp.next != self.head): temp = temp.next temp.next = newNode newNode.next = self.head #reverse the list def reverseList(self): if(self.head != None): prevNode = self.head tempNode = self.head curNode = self.head.next prevNode.next = prevNode while(curNode != self.head): tempNode = curNode.next curNode.next = prevNode self.head.next = curNode prevNode = curNode curNode = tempNode self.head = prevNode #display the content of the list def PrintList(self): temp = self.head if(temp != None): print("The list contains:", end=" ") while (True): print(temp.data, end=" ") temp = temp.next if(temp == self.head): break print() else: print("The list is empty.") # test the code MyList = LinkedList() #Add five elements in the list. MyList.push_back(10) MyList.push_back(20) MyList.push_back(30) MyList.push_back(40) MyList.push_back(50) #Display the content of the list. MyList.PrintList() #Reversing the list. MyList.reverseList() #Display the content of the list. MyList.PrintList()
The above code will give the following output:
The list contains: 10 20 30 40 50 The list contains: 50 40 30 20 10
//node structure class Node { int data; Node next; }; class LinkedList { Node head; LinkedList(){ head = null; } //Add new element at the end of the list void push_back(int newElement) { Node newNode = new Node(); newNode.data = newElement; newNode.next = null; if(head == null) { head = newNode; newNode.next = head; } else { Node temp = new Node(); temp = head; while(temp.next != head) temp = temp.next; temp.next = newNode; newNode.next = head; } } //reverse the list void reverseList() { if(this.head != null) { Node prevNode = this.head; Node tempNode = this.head; Node curNode = this.head.next; prevNode.next = prevNode; while(curNode != this.head) { tempNode = curNode.next; curNode.next = prevNode; this.head.next = curNode; prevNode = curNode; curNode = tempNode; } this.head = prevNode; } } //display the content of the list void PrintList() { Node temp = new Node(); temp = this.head; if(temp != null) { System.out.print("The list contains: "); while(true) { System.out.print(temp.data + " "); temp = temp.next; if(temp == this.head) break; } System.out.println(); } else { System.out.println("The list is empty."); } } }; // test the code public class Implementation { public static void main(String[] args) { LinkedList MyList = new LinkedList(); //Add five elements in the list. MyList.push_back(10); MyList.push_back(20); MyList.push_back(30); MyList.push_back(40); MyList.push_back(50); //Display the content of the list. MyList.PrintList(); //Reversing the list. MyList.reverseList(); //Display the content of the list. MyList.PrintList(); } }
The above code will give the following output:
The list contains: 10 20 30 40 50 The list contains: 50 40 30 20 10
using System; //node structure class Node { public int data; public Node next; }; class LinkedList { Node head; public LinkedList(){ head = null; } //Add new element at the end of the list public void push_back(int newElement) { Node newNode = new Node(); newNode.data = newElement; newNode.next = null; if(head == null) { head = newNode; newNode.next = head; } else { Node temp = new Node(); temp = head; while(temp.next != head) temp = temp.next; temp.next = newNode; newNode.next = head; } } //reverse the list public void reverseList() { if(this.head != null) { Node prevNode = this.head; Node tempNode = this.head; Node curNode = this.head.next; prevNode.next = prevNode; while(curNode != this.head) { tempNode = curNode.next; curNode.next = prevNode; this.head.next = curNode; prevNode = curNode; curNode = tempNode; } this.head = prevNode; } } //display the content of the list public void PrintList() { Node temp = new Node(); temp = this.head; if(temp != null) { Console.Write("The list contains: "); while(true) { Console.Write(temp.data + " "); temp = temp.next; if(temp == this.head) break; } Console.WriteLine(); } else { Console.WriteLine("The list is empty."); } } }; // test the code class Implementation { static void Main(string[] args) { LinkedList MyList = new LinkedList(); //Add five elements in the list. MyList.push_back(10); MyList.push_back(20); MyList.push_back(30); MyList.push_back(40); MyList.push_back(50); //Display the content of the list. MyList.PrintList(); //Reversing the list. MyList.reverseList(); //Display the content of the list. MyList.PrintList(); } }
The above code will give the following output:
The list contains: 10 20 30 40 50 The list contains: 50 40 30 20 10
<?php //node structure class Node { public $data; public $next; } class LinkedList { public $head; public function __construct(){ $this->head = null; } //Add new element at the end of the list public function push_back($newElement) { $newNode = new Node(); $newNode->data = $newElement; $newNode->next = null; if($this->head == null) { $this->head = $newNode; $newNode->next = $this->head; } else { $temp = new Node(); $temp = $this->head; while($temp->next !== $this->head) { $temp = $temp->next; } $temp->next = $newNode; $newNode->next = $this->head; } } //reverse the list public function reverseList() { if($this->head != null) { $prevNode = $this->head; $tempNode = $this->head; $curNode = $this->head->next; $prevNode->next = $prevNode; while($curNode != $this->head) { $tempNode = $curNode->next; $curNode->next = $prevNode; $this->head->next = $curNode; $prevNode = $curNode; $curNode = $tempNode; } $this->head = $prevNode; } } //display the content of the list public function PrintList() { $temp = new Node(); $temp = $this->head; if($temp != null) { echo "The list contains: "; while(true) { echo $temp->data." "; $temp = $temp->next; if($temp == $this->head) break; } echo "\n"; } else { echo "The list is empty.\n"; } } }; // test the code $MyList = new LinkedList(); //Add five elements in the list. $MyList->push_back(10); $MyList->push_back(20); $MyList->push_back(30); $MyList->push_back(40); $MyList->push_back(50); //Display the content of the list. $MyList->PrintList(); //Reversing the list. $MyList->reverseList(); //Display the content of the list. $MyList->PrintList(); ?>
The above code will give the following output:
The list contains: 10 20 30 40 50 The list contains: 50 40 30 20 10