Circular Linked List in C++

A circular linked list is a linear data structure similar to a singly linked list where each node consists of two data members data and a pointer next, that stores the address of the next node in the sequence but in a circular linked list, the last node of the list points to the first node instead of NULL creating a circular chain of nodes. In this article, we will learn how to implement a circular linked list in C++.

Implementation of Circular Linked List in C++

In C++, to create a , we need to define a class name Node that will consist of the data members for a node of the list. After that, we can create a CircularLinkedList class to encapsulate the data members and functions for the circular linked list.

Representation of Circular Linked List in C++

To represent a node of a circular linked list we will declare a classNode that will consist of two data members data and next where:

template <typename T>
class Node {
 public:
 T data;
 Node<T>* next;
};

where,

• data: represents the value present in the node.
• next: a pointer used to store the address of the succeeding node.

Note: Here we have used the templates to keep the circular linked list generic, users can store any type of data they want to store in the circular linked list.

The following diagram represents the structure of a circular linked list:

Basic Operations of a Circular Linked List in C++

Following are some of the basic operations that are required to work with circular linked list in C++:

Note: Here N represents the number of nodes in the circular linked list.

Implementation of Basic Circular Linked List Operations in C++

Algorithm for insertAtFirst

Following is the algorithm for inserting a node at the start of a circular linked list:

1. Create a new Node.
2. Confirm whether the circular linked list contains nodes or is empty
3. If the list is empty:
   1. Update the next pointer of the new node to point to itself.
   2. Set the new node as the head.
4. If the list is not empty:
   1. Set the next pointer of the new node to head.
   2. Iterate through the list to reach the last node.
   3. Update the next pointer of the last node to the new node that you have added.
   4. Update the new node as the head of the list.

Algorithm for insertAtEnd

Following is the algorithm for inserting a node at the end of the circular linked list:

1. Create a new Node.
2. Confirm whether the circular linked list contains nodes or is empty
3. If the list is empty:
   1. Update the next pointer of the new node to point to itself.
   2. Set the new node as the head.
4. If the list is not empty:
   1. Iterate through the list to reach the last node.
   2. Update the next pointer of the last node to the new node that you have added.
   3. Update the next pointer of new node to the head of the list.

Algorithm for insertAtPosition

Following is the algorithm for inserting a node at a given position in the circular linked list:

1. Create a new node with the given data.
2. Check if the given position is less than or equal to 1 or if the list is empty.
   • If true, call insertAtFirst with the given data.
3. If the list is not empty:
   • Initialize a pointer temp to point to the head of the list.
   • Iterate through the list to reach the node just before the given position or until the end of the list:
     • For i from 1 to position - 2 (inclusive), update temp to temp->next.
   • Update the next pointer of the new node to temp->next.
   • Update the next pointer of temp to point to the new node.

Deletion Operations in a Circular Linked List in C++

Algorithm for deleteFromFirst

Following is the algorithm for deleting the first node of a the circular linked list:

1. Check if the head pointer of the list is NULL or not. If NULL,return.
2. If the list contains only a single node, then delete the head node and update the Head pointer to NULL.
3. If the list has multiple nodes:
   1. Store the head of the list in a temporary pointer named temp.
   2. Iterate through the list to reach the last node.
   3. Update the next pointer of the last node to the next node of the head node.
   4. Update the head to the next node.
   5. Delete the temp node.

Algorithm for deleteFromEnd

Following is the algorithm for deleting the last node of a the circular linked list:

1. Check if the head pointer of the list is NULL or not. If NULL,return.
2. If the list contains only a single node, then delete the head node and update the Head pointer to NULL.
3. If the list has multiple nodes:
   1. Traverse to the node just before the last node in the list.
   2. Store the last node of the list in a temporary pointer named temp.
   3. Update the next pointer of the second last node to the head of the list.
   4. Delete the last node represented by temp pointer.

Algorithm for deleteByKey

Following is the algorithm for deleting a node with a given key in the circular linked list:

1. Check if the head pointer of the list is NULL. If NULL, return.
2. Check if the head node contains the key:
   • If true, call deleteFromFirst and return.
3. If the list has multiple nodes:
   • Initialize a pointer temp to point to the head of the list.
   • Initialize a pointer prev to NULL.
   • Iterate through the list to find the node with the given key:
     • Update prev to temp.
     • Update temp to temp->next.
     • Repeat until temp is equal to head or temp->data equals the key.
   • If the key is found (i.e., temp->data equals the key):
     • Update the next pointer of prev to temp->next.
     • Delete the temp node.

Algorithm for Display

Following is the algorithm for printing the nodes of a circular linked list:

• Check if the list is empty or not. If empty return.
• Create a temporary pointer temp and point it to the head of the list.
• Do:
  • Print the data of the temporary node.
  • Move temp to temp->next.
• While:
  • temporary pointer is not equal to head.

C++ Program for Circular Linked List

The below program demonstrates how we can implement a circular linked list in C++:

Output

Circular linked list after inserting node at the beginning:
10 -> HEAD
Circular linked list after inserting 20,30,40,50 at the end:
10 -> 20 -> 30 -> 40 -> 50 -> HEAD
Circular linked list after deleting the first node:
20 -> 30 -> 40 -> 50 -> HEAD
Circular linked list after deleting the last node :
20 -> 30 -> 40 -> HEAD

Applications of Circular Linked List

Following are some of the common applications of circular linked list in our daily lives:

• Circular Buffers (Ring Buffers): Circular linked lists are used to implement circular buffers that are used in the systems where the data needs to be overwritten in cyclic manner. They are commonly used in the buffering data streams.

• Round-Robin Scheduling: They are also used in operating systems to implement Round-robin scheduling CPU scheduling algorithm.

• Implementing Undo Functionality:Circular linked lists are also used in various applications to keep track of the sequence of activities in order to implement the undo functionality.

• Music Playlists: Music players that supports the repeat modes uses the circular linked list to cycle through the songs.

• Graphical User Interfaces: Circular linked lists are often used in various smart devices like TV, smartwatches to implement the menu where the users can navigate through the applications in cyclic manner.

Related Articles

You can also go through the following articles to improve your understanding about the linked lists:

• Linked List Data Structure
• Doubly Linked List
• Circular Linked List
• Introduction to Circular Doubly Linked List