Create a Circular Singly Linked List in DSA C++ - Build from Scratch

Create a Circular Singly Linked List

📖 Scenario: Imagine you want to organize a group of friends sitting around a round table. Each friend points to the next friend, and the last friend points back to the first, making a circle.

🎯 Goal: You will build a circular singly linked list in C++ that connects nodes in a circle. Then, you will print the list to see the circle in action.

📋 What You'll Learn

Create a Node class with an integer data and a pointer to the next node

Create three nodes with data 10, 20, and 30

Link the nodes so that the last node points back to the first node, forming a circle

Print the circular linked list starting from the head node, showing all nodes once

💡 Why This Matters

🌍 Real World

Circular linked lists are useful in real-world scenarios like managing players in a board game where turns repeat in a circle.

💼 Career

Understanding circular linked lists helps in jobs involving system design, game development, and real-time scheduling where circular data structures are common.

1

Create the Node class and three nodes

Create a class called Node with an integer data and a Node* pointer called next. Then create three nodes named node1, node2, and node3 with data values 10, 20, and 30 respectively.

DSA C++

// Your code here

Hint

Define the Node class with a constructor. Then create three nodes with the given values.

2

Link the nodes to form a circle

Link the nodes so that node1->next points to node2, node2->next points to node3, and node3->next points back to node1 to complete the circle.

DSA C++

class Node {
public:
    int data;
    Node* next;
    Node(int val) : data(val), next(nullptr) {}
};

Node* node1 = new Node(10);
Node* node2 = new Node(20);
Node* node3 = new Node(30);

// Link the nodes to form a circular list
// Your code here

Hint

Set each node's next pointer to the next node, and the last node's next to the first node.

3

Create a pointer to the head node

Create a pointer called head and set it to point to node1, the first node in the circular linked list.

DSA C++

class Node {
public:
    int data;
    Node* next;
    Node(int val) : data(val), next(nullptr) {}
};

Node* node1 = new Node(10);
Node* node2 = new Node(20);
Node* node3 = new Node(30);

node1->next = node2;
node2->next = node3;
node3->next = node1;

// Create a pointer to the head node
// Your code here

Hint

Set head to point to the first node node1.

4

Print the circular linked list

Write a while loop to print the data of each node starting from head. Stop after printing all three nodes once to avoid an infinite loop. Use a pointer current to traverse the list and print the data separated by ->. End with null.

DSA C++

class Node {
public:
    int data;
    Node* next;
    Node(int val) : data(val), next(nullptr) {}
};

Node* node1 = new Node(10);
Node* node2 = new Node(20);
Node* node3 = new Node(30);

node1->next = node2;
node2->next = node3;
node3->next = node1;

Node* head = node1;

// Print the circular linked list
// Your code here

Hint

Use a counter to print exactly three nodes to avoid infinite looping in the circular list.

Practice

1. What is a key characteristic of a circular singly linked list compared to a regular singly linked list?

easy

A. It uses an array internally to store nodes.

B. Each node has two pointers, one to the next and one to the previous node.

C. It cannot be traversed starting from the head node.

D. The last node points back to the first node, forming a circle.

Solution

1. Step 1: Understand the structure of a circular singly linked list

   In a circular singly linked list, the last node's next pointer points back to the first node, creating a loop.

2. Step 2: Compare with other linked lists

   Unlike doubly linked lists (which have two pointers) or arrays, circular singly linked lists have a single pointer per node and form a circle.

3. Final Answer:

   The last node points back to the first node, forming a circle. -> Option D

4. Quick Check:

   Circular list = last node points to first node [OK]

Hint: Remember: circular means last node links back to first [OK]

Common Mistakes:

• Thinking circular means two pointers per node
• Confusing with doubly linked list
• Assuming it uses arrays internally

2. Which of the following is the correct way to declare a node structure for a circular singly linked list in C++?

easy

A. struct Node { int data; int next; }; // Incorrect pointer type

B. struct Node { int data; Node* prev; Node* next; }; // Doubly linked list node

C. struct Node { int data; Node* next; }; // Correct declaration

D. struct Node { int data; Node next; }; // Incorrect pointer usage

Solution

1. Step 1: Identify the correct node structure for singly linked list

   A singly linked list node has data and a pointer to the next node. The pointer type must be Node*.

2. Step 2: Check each option

   struct Node { int data; Node* next; }; // Correct declaration correctly declares Node* next. struct Node { int data; Node* prev; Node* next; }; // Doubly linked list node has an extra prev pointer (doubly linked list). struct Node { int data; int next; }; // Incorrect pointer type uses int next which is wrong type. struct Node { int data; Node next; }; // Incorrect pointer usage uses Node next which is not a pointer.

3. Final Answer:

   struct Node { int data; Node* next; }; -> Option C

4. Quick Check:

   Single pointer to next node = correct node structure [OK]

Hint: Node must have pointer to next node only [OK]

Common Mistakes:

• Using non-pointer type for next
• Adding prev pointer for singly linked list
• Declaring next as object instead of pointer

3. What will be the output of the following code snippet that creates a circular singly linked list with 3 nodes and prints their data?

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

int main() {
    Node* head = new Node{1, nullptr};
    Node* second = new Node{2, nullptr};
    Node* third = new Node{3, nullptr};

    head->next = second;
    second->next = third;
    third->next = head; // circular link

    Node* temp = head;
    for (int i = 0; i < 5; i++) {
        std::cout << temp->data << " ";
        temp = temp->next;
    }
    return 0;
}

medium

A. 1 2 3 1 2

B. 1 2 3 3 3

C. 1 2 3 4 5

D. 1 2 3 1 1

Solution

1. Step 1: Understand the circular link setup

   The last node (third) points back to head, so the list loops: 1 -> 2 -> 3 -> 1 -> ...

2. Step 2: Trace the print loop for 5 iterations

   Starting at head (1), print 1, move to 2, print 2, move to 3, print 3, move to 1, print 1, move to 2, print 2.

3. Final Answer:

   1 2 3 1 2 -> Option A

4. Quick Check:

   Loop prints nodes in circle: 1 2 3 1 2 [OK]

Hint: Circular list repeats nodes after last one [OK]

Common Mistakes:

• Assuming list ends after 3 nodes
• Printing wrong data due to pointer errors
• Confusing circular with linear list output

4. Identify the error in the following code that attempts to create a circular singly linked list with one node:

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

int main() {
    Node* head = new Node{10, nullptr};
    head->next = nullptr; // Intended to make circular
    return 0;
}

medium

A. Memory leak due to missing delete statement.

B. head->next should point to head, not nullptr, to form a circular list.

C. Using nullptr for next is correct for circular list.

D. Node declaration is missing a constructor.

Solution

1. Step 1: Check how circular link is formed

   For a circular singly linked list with one node, the node's next pointer must point to itself.

2. Step 2: Identify the mistake in the code

   The code sets head->next = nullptr, which breaks the circular property.

3. Final Answer:

   head->next should point to head, not nullptr, to form a circular list. -> Option B

4. Quick Check:

   One node circular list: next points to itself [OK]

Hint: One node circular list points next to itself [OK]

Common Mistakes:

• Setting next to nullptr instead of self
• Confusing circular with linear list
• Ignoring memory management issues (not relevant here)

5. You want to insert a new node with value 4 at the end of an existing circular singly linked list with nodes 1 -> 2 -> 3 -> back to 1. Which of the following code snippets correctly performs this insertion?

hard

A. Node* newNode = new Node{4, head};
Node* temp = head;
while (temp->next != head) temp = temp->next;
temp->next = newNode;

B. Node* newNode = new Node{4, nullptr};
Node* temp = head;
while (temp->next != nullptr) temp = temp->next;
temp->next = newNode;
newNode->next = head;

C. Node* newNode = new Node{4, head};
head->next = newNode;

D. Node* newNode = new Node{4, nullptr};
newNode->next = head;
head = newNode;

Solution

1. Step 1: Understand insertion at end in circular singly linked list

   To insert at end, find last node (whose next points to head), then link new node to head and last node to new node.

2. Step 2: Analyze each option

   Node* newNode = new Node{4, head}; Node* temp = head; while (temp->next != head) temp = temp->next; temp->next = newNode; correctly creates new node pointing to head, finds last node by looping until temp->next == head, then sets last node's next to new node. Node* newNode = new Node{4, nullptr}; Node* temp = head; while (temp->next != nullptr) temp = temp->next; temp->next = newNode; newNode->next = head; incorrectly checks for nullptr which does not exist in circular list. Node* newNode = new Node{4, head}; head->next = newNode; incorrectly sets head->next to new node, breaking list. Node* newNode = new Node{4, nullptr}; newNode->next = head; head = newNode; changes head pointer incorrectly and does not update last node's next.

3. Final Answer:

   Node* newNode = new Node{4, head}; Node* temp = head; while (temp->next != head) temp = temp->next; temp->next = newNode; -> Option A

4. Quick Check:

   Find last node by next == head, link new node to head, last node to new node [OK]

Hint: Loop until next points to head to find last node [OK]

Common Mistakes:

• Checking for nullptr in circular list
• Not updating last node's next pointer
• Incorrectly changing head pointer