# Doubly Circular Linked List Introduction and Insertion ### Introduction

In this blog, we will study the doubly circular linked list introduction and insertion. A doubly circular linked list is a linked list that has the features of both the lists i.e. Doubly linked list and circular linked list. In a doubly circular linked list, two nodes are connected or linked together by the previous and the next pointers, and the last node of the doubly circular linked list is connected to the first node of the doubly circular linked list.

• A Doubly Linked List is a linked data structure that is represented as a set of nodes.
• A node in a doubly linked list is an object which contains a value, a reference to the previous node of the list and a reference to the next node of the list.
• A doubly linked list consists of two node pointers next and prev, which point to next and previous nodes, respectively.
• Unlike the singly linked list, we can traverse in both directions in a doubly-linked list with the help of these next and prev pointers.

• A Doubly Circular Linked List is a data structure that has properties of both Circular Linked List and Doubly Linked List.
• It is a list in which the last node of the list points to the start node, creating a loop.
• As a doubly circular linked list is a combination of a doubly and a circular linked list, we can traverse in both directions, and also the last node of the list connects to the start node as next, and the start node has the last node in the prev pointer.

#### Structure of node:

```#include<stdio.h>
#include<stdlib.h>

struct Node
{
int data;
struct Node *next;
struct Node *prev;
};
```
```struct node
{
int data;
struct node *next; // Pointer to next node
struct node *prev; // Pointer to previous node
};
```
```static class Node
{
int data;
Node next;
Node prev;
};
```
```class Node:
def __init__(self, data = None, prev = None, next = None):
self.data = data
self.prev = prev
self.next = next
```

### Problem Statement Understanding

We have to create a Doubly Circular Linked List by inserting nodes in the list, i.e., by adding nodes at the start or the end of the List, and after performing all the insertion operations, we need to output the created list.

Suppose we are given an empty linked list and some insertion operations to perform on the linked list. Look at the figure below to see how insertions will happen.  Now I think from the above figure, you got the idea, how insertions will happen in the list. So let’s now see the algorithm to do these insertions.

### Approach and Algorithm

• Firstly, we will initialize the start node as NULL, and then we can continue to insert the nodes.
• The following cases persist if we want to insert the nodes:

a) If the list is empty

• We will create a new_node with the given value.
• Assign the prev and next of new_node to the new_node itself.
• Update new_node as the start node.

b) Insert at begin

• We will create a new_node with the given value.
• Assign the next of new_node as the start node.
• Assign the prev of new_node to the last node of the linked list.
• Update the prev of the start node and next of the last node as new_node.
• Update new_node as the start node.

c) Insert at the end

• We will create a new_node with the given value.
• Assign the next of new_node as the start node.
• Assign the prev of new_node to the last node of the list.
• Update the prev of the start node and next of the last node as new_node.
• Update new_node as the last node.
• Using these above insertion operations, our Doubly Circular Linked List will get created.
• Now, finally, once we have inserted all the nodes in the list, we can print the list.

### Dry Run    ### Code Implementation:

```#include<stdio.h>
#include<stdlib.h>

struct Node
{
int data;
struct Node *next;
struct Node *prev;
};

// Function to insert at the end
void insertEnd(struct Node** start, int value)
{
if (*start == NULL)
{
struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
new_node->data = value;
new_node->next = new_node->prev = new_node;
*start = new_node;
return;
}

// If list is not empty

/* Find last node */
struct Node *last = (*start)->prev;

// Create Node dynamically
struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
new_node->data = value;

// Start is going to be next of new_node
new_node->next = *start;

// Make new node previous of start
(*start)->prev = new_node;

// Make last previous of new node
new_node->prev = last;

// Make new node next of old last
last->next = new_node;
}

// Function to insert Node at the beginning
// of the List,
void insertBegin(struct Node** start, int value)
{
// Pointer points to last Node
struct Node *last = (*start)->prev;

struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
new_node->data = value;   // Inserting the data

// setting up previous and next of new node
new_node->next = *start;
new_node->prev = last;

// Update next and previous pointers of start
// and last.
last->next = (*start)->prev = new_node;

// Update start pointer
*start = new_node;
}

// Function to insert node with value as value1.
// The new node is inserted after the node with
// with value2
void insertAfter(struct Node** start, int value1,
int value2)
{
struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
new_node->data = value1; // Inserting the data

// Find node having value2 and next node of it
struct Node *temp = *start;
while (temp->data != value2)
temp = temp->next;
struct Node *next = temp->next;

// insert new_node between temp and next.
temp->next = new_node;
new_node->prev = temp;
new_node->next = next;
next->prev = new_node;
}

void display(struct Node* start)
{
struct Node *temp = start;

printf("\nTraversal in forward direction \n");
while (temp->next != start)
{
printf("%d ", temp->data);
temp = temp->next;
}
printf("%d ", temp->data);

printf("\nTraversal in reverse direction \n");
struct Node *last = start->prev;
temp = last;
while (temp->prev != last)
{
printf("%d ", temp->data);
temp = temp->prev;
}
printf("%d ", temp->data);
}

/* Driver program to test above functions*/
int main()
{
struct Node* start = NULL;

// Insert 5. So linked list becomes 5->NULL
insertEnd(&start, 5);

// Insert 4 at the beginning. So linked
// list becomes 4->5
insertBegin(&start, 4);

// Insert 7 at the end. So linked list
// becomes 4->5->7
insertEnd(&start, 7);

// Insert 8 at the end. So linked list
// becomes 4->5->7->8
insertEnd(&start, 8);

// Insert 6, after 5. So linked list
// becomes 4->5->6->7->8
insertAfter(&start, 6, 5);

printf("Created circular doubly linked list is: ");
display(start);

return 0;
}

```
```class Prepbytes {

static Node start;

static class Node {
int data;
Node next;
Node prev;
};

static void insertEnd(int value) {

if (start == null) {
Node new_node = new Node();
new_node.data = value;
new_node.next = new_node.prev = new_node;
start = new_node;
return;
}

Node last = (start).prev;

Node new_node = new Node();
new_node.data = value;

new_node.next = start;

(start).prev = new_node;

new_node.prev = last;

last.next = new_node;
}

static void insertBegin(int value) {
if (start == null) {
Node new_node = new Node();
new_node.data = value;
new_node.next = new_node.prev = new_node;
start = new_node;
return;
}

Node last = (start).prev;

Node new_node = new Node();
new_node.data = value;

new_node.next = start;
new_node.prev = last;

last.next = (start).prev = new_node;

start = new_node;
}

static void display() {
Node temp = start;

System.out.printf("\nTraversal in forward direction \n");
while (temp.next != start) {
System.out.printf("%d ", temp.data);
temp = temp.next;
}
System.out.printf("%d ", temp.data);

System.out.printf("\nTraversal in reverse direction \n");
Node last = start.prev;
temp = last;
while (temp.prev != last) {
System.out.printf("%d ", temp.data);
temp = temp.prev;
}
System.out.printf("%d ", temp.data);
}

public static void main(String[] args) {

Node start = null;
insertEnd(7);
insertBegin(3);
insertBegin(4);
insertEnd(6);
insertEnd(9);
insertBegin(8);
insertBegin(5);
System.out.printf("Created circular doubly linked list is: ");
display();
}
}
```
```start = None

class Node:
def __init__(self, data):
self.data = data
self.next = None
self.prev = None

def insertEnd(value) :
global start

if (start == None) :

new_node = Node(0)
new_node.data = value
new_node.next = new_node.prev = new_node
start = new_node
return

last = (start).prev
new_node = Node(0)
new_node.data = value
new_node.next = start
(start).prev = new_node
new_node.prev = last
last.next = new_node

def insertBegin( value) :
global start

if start == None:
new_node = Node(0)
new_node.data = value
new_node.next = new_node.prev = new_node
start = new_node
return
last = (start).prev

new_node = Node(0)
new_node.data = value
new_node.next = start
new_node.prev = last
last.next = (start).prev = new_node
start = new_node

def display() :
global start
temp = start

print ("Traversal in forward direction:")
while (temp.next != start) :

print (temp.data, end = " ")
temp = temp.next

print (temp.data)

print ("Traversal in reverse direction:")
last = start.prev
temp = last
while (temp.prev != last) :

print (temp.data, end = " ")
temp = temp.prev

print (temp.data)

if __name__ == '__main__':

start = None
insertEnd(7)
insertBegin(3)
insertBegin(4)
insertEnd(6)
insertEnd(9)
insertBegin(8)
insertBegin(5)

print ("Created circular doubly linked list is: ")
display()
```

#### Output

Created circular doubly linked list is:
Traversal in forward direction
5 8 4 3 7 6 9
Traversal in reverse direction
9 6 7 3 4 8 5

Time Complexity: O(1) for insertion as insertion is a constant operation.
Space Complexity: O(n), space is required to create n nodes.

So, in this blog, we have discussed Doubly Circular Linked List Introduction and Insertion. We hope you will understand the doubly circular linked list clearly, also you can follow this link Linked List for practicing more questions about a linked list.

## FAQs

1. What is a doubly circular linked list?
2. A doubly circular linked list is defined as the nodes which are connected together with the previous node and the next node, and the last node of the doubly circular linked list is connected to the first node of the list.

3. What is the difference between a doubly linked list and doubly circular linked list?
4. In the doubly linked list, every node holds the address of the previous node as well as the next node whereas in the doubly circular linked list every node holds the address of the previous node as well as the next node and the first node holds the pointer of the last node, which makes the doubly linked list as a doubly circular linked list.