CIRCULAR LINKED LIST :

The circular linked list is a linked list where all nodes are connected to
form a circle. In a circular linked list, the first node and the last node are
connected to each other which forms a circle. There is no NULL at the end.

There are generally two types of circular linked lists:

Circular singly linked list:

In a circular Singly linked list, the last node of the list contains a pointer to
the first node of the list. We traverse the circular singly linked list until we
reach the same node where we started. The circular singly linked list has
no beginning or end. No null value is present in the next part of any of the
nodes.

Circular Doubly linked list:

Circular Doubly Linked List has properties of both doubly linked list and
circular linked list in which two consecutive elements are linked or
connected by the previous and next pointer and the last node points to the
first node by the next pointer and also the first node points to the last
node by the previous pointer.

Representation of circular linked list:

Circular linked lists are similar to single Linked Lists with the exception of
connecting the last node to the first node.
Node representation of a Circular Linked List:
struct Node {
int data;
struct Node *next;
};
Example of Circular singly linked list:

The above Circular singly linked list can be represented as:

Node* one = createNode(3);

Node* two = createNode(5);
Node* three = createNode(9);
// Connect nodes
one->next = two;
two->next = three;
three->next = one;

In the above program one, two, and three are the node with values 3, 5,
and 9 respectively which are connected in a circular manner as:
● For Node One: The Next pointer stores the address of Node two.

● For Node Two: The Next stores the address of Node three

● For Node Three: The Next points to node one.

Operations on the circular linked list:

We can do some operations on the circular linked list similar to the singly
linked list which are:
1. Insertion

2. Deletion

1. Insertion in the circular linked list:

A node can be added in three ways:

1. Insertion at the beginning of the list

2. Insertion at the end of the list

3. Insertion in between the nodes

1) Insertion at the beginning of the list: To insert a node at the beginning

of the list, follow these steps:
 ● Create a node, say T.

● Make T -> next = last -> next.

● last -> next = T.

Circular linked list before insertion

And then,

Circular linked list after insertion

2) Insertion at the end of the list: To insert a node at the end of the list,
follow these steps:
● Create a node, say T.

● Make T -> next = last -> next;

● last -> next = T.

● last = T.

Before insertion,
 Circular linked list before insertion of node at the end

After insertion,

Circular linked list after insertion of node at the end

3) Insertion in between the nodes: To insert a node in between the two

nodes, follow these steps:
● Create a node, say T.

● Search for the node after which T needs to be inserted, say that

node is P.

● Make T -> next = P -> next;

● P -> next = T.

Suppose 12 needs to be inserted after the node has the value 10,
 Circular linked list before insertion

After searching and insertion,

Circular linked list after insertion

2. Deletion in a circular linked list:

1) Delete the node only if it is the only node in the circular linked list:
● Free the node’s memory

● The last value should be NULL A node always points to another

node, so NULL assignment is not necessary.

Any node can be set as the starting point.

Nodes are traversed quickly from the first to the last.

2) Deletion of the last node:

● Locate the node before the last node (let it be temp)

 ● Keep the address of the node next to the last node in temp

● Delete the last memory

● Put temp at the end

3) Delete any node from the circular linked list: We will be given a node
and our task is to delete that node from the circular linked list.
Algorithm:
Case 1: List is empty.
● If the list is empty we will simply return.

Case 2:List is not empty

● If the list is not empty then we define two pointers curr and prev
and initialize the pointer curr with the head node.
● Traverse the list using curr to find the node to be deleted and
before moving to curr to the next node, every time set prev =
curr.
● If the node is found, check if it is the only node in the list. If yes,
set head = NULL and free(curr).
● If the list has more than one node, check if it is the first node of
the list. Condition to check this( curr == head). If yes, then move
prev until it reaches the last node. After prev reaches the last
node, set head = head -> next and prev -> next = head. Delete
curr.
● If curr is not the first node, we check if it is the last node in the
list. Condition to check this is (curr -> next == head).
● If curr is the last node. Set prev -> next = head and delete the
node curr by free(curr).
● If the node to be deleted is neither the first node nor the last
node, then set prev -> next = curr -> next and delete curr.
● If the node is not present in the list return head and don’t do
anything.
Below is the implementation for the above approach:

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

// Structure for a node

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

// Function to insert a node at the

// beginning of a Circular linked list
void push(struct Node** head_ref, int data)
{

// Create a new node and make head

// as next of it.
struct Node* ptr1 = (struct Node*)malloc(sizeof(struct Node));
ptr1->data = data;
ptr1->next = *head_ref;

// If linked list is not NULL then

// set the next of last node
if (*head_ref != NULL) {
 // Find the node before head and
// update next of it.
struct Node* temp = *head_ref;
while (temp->next != *head_ref)
temp = temp->next;
temp->next = ptr1;
}
else

// For the first node

ptr1->next = ptr1;

*head_ref = ptr1;
}

// Function to print nodes in a given

// circular linked list
void printList(struct Node* head)
{
struct Node* temp = head;
if (head != NULL) {
do {
printf("%d ", temp->data);
temp = temp->next;
} while (temp != head);
}
 printf("\n");
}

// Function to delete a given node

// from the list
void deleteNode(struct Node** head, int key)
{

// If linked list is empty

if (*head == NULL)
return;

// If the list contains only a

// single node
if ((*head)->data == key && (*head)->next == *head) {
free(*head);
*head = NULL;
return;
}

struct Node *last = *head, *d;

// If head is to be deleted
if ((*head)->data == key) {

// Find the last node of the list

while (last->next != *head)
 last = last->next;

// Point last node to the next of

// head i.e. the second node
// of the list
last->next = (*head)->next;
free(*head);
*head = last->next;
return;
}

// Either the node to be deleted is

// not found or the end of list
// is not reached
while (last->next != *head && last->next->data != key) {
last = last->next;
}

// If node to be deleted was found

if (last->next->data == key) {
d = last->next;
last->next = d->next;
free(d);
}
else
printf("Given node is not found in the list!!!\n");
}
// Driver code
int main()
{
// Initialize lists as empty
struct Node* head = NULL;

// Created linked list will be

// 2->5->7->8->10
push(&head, 2);
push(&head, 5);
push(&head, 7);
push(&head, 8);
push(&head, 10);

printf("List Before Deletion: ");

printList(head);

deleteNode(&head, 7);

printf("List After Deletion: ");

printList(head);

return 0;
}
DOUBLY LINKED LIST:

A doubly linked list (DLL) is a special type of linked list in which each node contains
a pointer to the previous node as well as the next node of the linked list.

Given below is a representation of a DLL node:

// Node of a doubly linked list

struct Node {
int data;

// Pointer to next node in DLL

struct Node* next;

// Pointer to previous node in DLL

struct Node* prev;
};

Insertion in a Doubly Linked List:

Inserting a new node in a doubly linked list is very similar to inserting a new
node in a linked list. There is a little extra work required to maintain the link
of the previous node. A node can be inserted in a Doubly Linked List in four
ways:
● At the front of the DLL.

● In between two nodes

● After a given node.

 ● Before a given node.

● At the end of the DLL.

Add a node at the front in a Doubly Linked List:

The new node is always added before the head of the given Linked List. The

task can be performed by using the following 5 steps:

1. Firstly, allocate a new node (say new_node).

2. Now put the required data in the new node.

3. Make the next of new_node point to the current head of the doubly

linked list.

4. Make the previous of the current head point to new_node.

5. Lastly, point head to new_node.

Below is the implementation of the 5 steps to insert a node at the front of the

linked list:

// Given a reference (pointer to pointer) to the head

// of a list and an int, inserts a new node

// on the front of the list.

void push(struct Node** head_ref, int new_data)

// 1. allocate node

struct Node* new_node

= (struct Node*)malloc(sizeof(struct Node));

// 2. put in the data

new_node->data = new_data;

// 3. Make next of new node as head and previous as NULL

new_node->next = (*head_ref);

new_node->prev = NULL;

// 4. change prev of head node to new node

if ((*head_ref) != NULL)

(*head_ref)->prev = new_node;

// 5. move the head to point to the new node

 (*head_ref) = new_node;

Add a node in between two nodes:

It is further classified into the following two parts:

Add a node after a given node in a Doubly Linked List:

We are given a pointer to a node as prev_node, and the new node is inserted

after the given node. This can be done using the following 6 steps:

1. Firstly create a new node (say new_node).

2. Now insert the data in the new node.

3. Point the next of new_node to the next of prev_node.

4. Point the next of prev_node to new_node.

5. Point the previous of new_node to prev_node.

6. Change the pointer of the new node’s previous pointer to

new_node.

Below is the implementation of the 7 steps to insert a node after a given

node in the linked list:

// Given a node as prev_node, insert a new node

// after the given node

void insertAfter(struct Node* prev_node, int new_data)

// Check if the given prev_node is NULL

if (prev_node == NULL) {

printf("the given previous node cannot be NULL");

return;

// 1. allocate new node

struct Node* new_node

= (struct Node*)malloc(sizeof(struct Node));

// 2. put in the data

new_node->data = new_data;

// 3. Make next of new node as next of prev_node

new_node->next = prev_node->next;
 // 4. Make the next of prev_node as new_node

prev_node->next = new_node;

// 5. Make prev_node as previous of new_node

new_node->prev = prev_node;

// 6. Change previous of new_node's next node

if (new_node->next != NULL)

new_node->next->prev = new_node;

Add a node before a given node in a Doubly Linked List:

Let the pointer to this given node be next_node. This can be done using the

following 6 steps.

1. Allocate memory for the new node, let it be called new_node.

2. Put the data in new_node.

3. Set the previous pointer of this new_node as the previous node of

the next_node.

4. Set the previous pointer of the next_node as the new_node.

5. Set the next pointer of this new_node as the next_node.

6. Now set the previous pointer of new_node.

 ● If the previous node of the new_node is not NULL, then set

the next pointer of this previous node as new_node.

● Else, if the prev of new_node is NULL, it will be the new

head node.

Implementation

// Given a node as prev_node, insert a new node

// after the given node

void insertBefore(struct Node* next_node, int new_data)

// Check if the given next_node is NULL

if (next_node == NULL) {

printf("the given next node cannot be NULL");

return;

}
// 1. Allocate new node

struct Node* new_node

= (struct Node*)malloc(sizeof(struct Node));

// 2. Put in the data

new_node->data = new_data;

// 3. Make previous of new node as previous of next_node

new_node->prev = next_node->prev;

// 4. Make the previous of next_node as new_node

next_node->prev = new_node;

// 5. Make next_node as next of new_node

new_node->next = next_node;

// 6. Change next of new_node's previous node

if (new_node->prev != NULL)

new_node->prev->next = new_node;
 else

head = new_node;

Add a node at the end in a Doubly Linked List:

The new node is always added after the last node of the given Linked List.
This can be done using the following 7 steps:
1. Create a new node (say new_node).

2. Put the value in the new node.

3. Make the next pointer of new_node as null.

4. If the list is empty, make new_node as the head.

5. Otherwise, travel to the end of the linked list.

6. Now make the next pointer of last node point to new_node.

7. Change the previous pointer of new_node to the last node of the

list.

Implementation of the above Linked List approach:

// Given a reference (pointer to pointer) to the head

// of a DLL and an int, appends a new node at the end

void append(struct Node** head_ref, int new_data)

// 1. allocate node

struct Node* new_node

= (struct Node*)malloc(sizeof(struct Node));

struct Node* last = *head_ref; /* used in step 5*/

// 2. put in the data

new_node->data = new_data;

// 3. This new node is going to be the last node, so

// make next of it as NULL

new_node->next = NULL;

// 4. If the Linked List is empty, then make the new

// node as head

if (*head_ref == NULL) {

new_node->prev = NULL;

*head_ref = new_node;
 return;

// 5. Else traverse till the last node

while (last->next != NULL)

last = last->next;

// 6. Change the next of last node

last->next = new_node;

// 7. Make last node as previous of new node

new_node->prev = last;

return;