# Circular Doubly Linked List - Reverse the List

While working with a circular doubly 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 and previous 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

//2. assign next and previous of prevNode
//   as itself to make the first node as last
//   node of the reversed list
prevNode->next = prevNode;
prevNode->prev = prevNode;

//   from front and modify curNode and prevNode)
tempNode = curNode->next;

curNode->next = prevNode;
prevNode->prev = curNode;

prevNode = curNode;
curNode = tempNode;
}

//4. Make prevNode (last node) as head
}
}
```
```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

//2. assign next and previous of prevNode
//   as itself to make the first node as last
//   node of the reversed list
prevNode->next = prevNode;
prevNode->prev = prevNode;

//   from front and modify curNode and prevNode)
tempNode = curNode->next;

curNode->next = prevNode;
prevNode->prev = curNode;

prevNode = curNode;
curNode = tempNode;
}

//4. Make prevNode (last node) as head
}
}
```
```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

#2. assign next and previous of prevNode
#   as itself to make the first node as last
#   node of the reversed list
prevNode.next = prevNode
prevNode.prev = prevNode

#   from front and modify curNode and prevNode)
tempNode = curNode.next

curNode.next = prevNode
prevNode.prev = curNode

prevNode = curNode
curNode = tempNode

#4. Make prevNode (last node) as head
```
```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

//2. assign next and previous of prevNode
//   as itself to make the first node as last
//   node of the reversed list
prevNode.next = prevNode;
prevNode.prev = prevNode;

//   from front and modify curNode and prevNode)
tempNode = curNode.next;

curNode.next = prevNode;
prevNode.prev = curNode;

prevNode = curNode;
curNode = tempNode;
}

//4. Make prevNode (last node) as head
}
}
```
```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

//2. assign next and previous of prevNode
//   as itself to make the first node as last
//   node of the reversed list
prevNode.next = prevNode;
prevNode.prev = prevNode;

//   from front and modify curNode and prevNode)
tempNode = curNode.next;

curNode.next = prevNode;
prevNode.prev = curNode;

prevNode = curNode;
curNode = tempNode;
}

//4. Make prevNode (last node) as head
}
}
```
```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

//2. assign next and previous of prevNode
//   as itself to make the first node as last
//   node of the reversed list
\$prevNode->next = \$prevNode;
\$prevNode->prev = \$prevNode;

//   from front and modify curNode and prevNode)
\$tempNode = \$curNode->next;

\$curNode->next = \$prevNode;
\$prevNode->prev = \$curNode;

\$prevNode = \$curNode;
\$curNode = \$tempNode;
}

//4. Make prevNode (last node) as head
}
}
```

The below is a complete program that uses above discussed concept to reverse a given circular doubly linked list.

```#include <iostream>
using namespace std;

//node structure
struct Node {
int data;
Node* next;
Node* prev;
};

private:
public:
}

//Add new element at the end of the list
void push_back(int newElement) {
Node* newNode = new Node();
newNode->data = newElement;
newNode->next = NULL;
newNode->prev = NULL;
} else {
temp = temp->next;
temp->next = newNode;
newNode->prev = temp;
}
}

//reverse the list
void reverseList() {

prevNode->next = prevNode;
prevNode->prev = prevNode;

tempNode = curNode->next;

curNode->next = prevNode;
prevNode->prev = curNode;

prevNode = curNode;
curNode = tempNode;
}

}
}

//display the content of the list
void PrintList() {
if(temp != NULL) {
cout<<"The list contains: ";
while(true) {
cout<<temp->data<<" ";
temp = temp->next;
break;
}
cout<<endl;
} else {
cout<<"The list is empty.\n";
}
}
};

// test the code
int main() {

//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;
struct Node* prev;
};

//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;
newNode->prev = NULL;
} else {
temp = temp->next;
}
temp->next = newNode;
newNode->prev = temp;
}
}

//reverse the list

prevNode->next = prevNode;
prevNode->prev = prevNode;

tempNode = curNode->next;

curNode->next = prevNode;
prevNode->prev = curNode;

prevNode = curNode;
curNode = tempNode;
}

}
}

//display the content of the list
printf("The list contains: ");
while (1) {
printf("%i ",temp->data);
temp = temp->next;
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
self.prev = None

def __init__(self):

#Add new element at the end of the list
def push_back(self, newElement):
newNode = Node(newElement)
return
else:
temp = temp.next
temp.next = newNode
newNode.prev = temp

#reverse the list
def reverseList(self):

prevNode.next = prevNode
prevNode.prev = prevNode

tempNode = curNode.next

curNode.next = prevNode
prevNode.prev = curNode

prevNode = curNode
curNode = tempNode

#display the content of the list
def PrintList(self):
if(temp != None):
print("The list contains:", end=" ")
while (True):
print(temp.data, end=" ")
temp = temp.next
break
print()
else:
print("The list is empty.")

# test the code

#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;
Node prev;
};

}

//Add new element at the end of the list
void push_back(int newElement) {
Node newNode = new Node();
newNode.data = newElement;
newNode.next = null;
newNode.next = null;
} else {
Node temp = new Node();
temp = temp.next;
temp.next = newNode;
newNode.prev = temp;
}
}

//reverse the list
void reverseList() {

prevNode.next = prevNode;
prevNode.prev = prevNode;

tempNode = curNode.next;

curNode.next = prevNode;
prevNode.prev = curNode;

prevNode = curNode;
curNode = tempNode;
}

}
}

//display the content of the list
void PrintList() {
Node temp = new Node();
if(temp != null) {
System.out.print("The list contains: ");
while(true) {
System.out.print(temp.data + " ");
temp = temp.next;
break;
}
System.out.println();
} else {
System.out.println("The list is empty.");
}
}
};

// test the code
public class Implementation {
public static void main(String[] args) {

//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;
public Node prev;
};

}

//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;
newNode.prev = null;
} else {
Node temp = new Node();
temp = temp.next;
temp.next = newNode;
newNode.prev = temp;
}
}

//reverse the list
public void reverseList() {

prevNode.next = prevNode;
prevNode.prev = prevNode;

tempNode = curNode.next;

curNode.next = prevNode;
prevNode.prev = curNode;

prevNode = curNode;
curNode = tempNode;
}

}
}

//display the content of the list
public void PrintList() {
Node temp = new Node();
if(temp != null) {
Console.Write("The list contains: ");
while(true) {
Console.Write(temp.data + " ");
temp = temp.next;
break;
}
Console.WriteLine();
} else {
Console.WriteLine("The list is empty.");
}
}
};

// test the code
class Implementation {
static void Main(string[] args) {

//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;
public \$prev;
}

public function __construct(){
}

//Add new element at the end of the list
public function push_back(\$newElement) {
\$newNode = new Node();
\$newNode->data = \$newElement;
\$newNode->next = null;
\$newNode->prev = null;
} else {
\$temp = new Node();
\$temp = \$temp->next;
}
\$temp->next = \$newNode;
\$newNode->prev = \$temp;
}
}

//reverse the list
public function reverseList() {

\$prevNode->next = \$prevNode;
\$prevNode->prev = \$prevNode;

\$tempNode = \$curNode->next;

\$curNode->next = \$prevNode;
\$prevNode->prev = \$curNode;

\$prevNode = \$curNode;
\$curNode = \$tempNode;
}

}
}

//display the content of the list
public function PrintList() {
\$temp = new Node();
if(\$temp != null) {
echo "The list contains: ";
while(true) {
echo \$temp->data." ";
\$temp = \$temp->next;
break;
}
echo "\n";
} else {
echo "The list is empty.\n";
}
}
};

// test the code

//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
```

5