Why Circular Linked List and Real World Use Cases in DSA C++ - Test Your Knowledge

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a circular linked list by linking the last node back to the head.

DSA C++

Node* head = new Node(1);
Node* second = new Node(2);
head->next = second;
second->next = [1];

Drag options to blanks, or click blank then click option'

Asecond

Bnullptr

Chead

Dnew Node(3)

Attempts:

3 left

💡 Hint

Common Mistakes

Setting the last node's next to nullptr breaks the circular link.

Pointing last node to itself creates a single-node loop, not the intended list.

In a circular linked list, the last node points back to the head node, making the list circular.

2fill in blank

medium

Complete the code to traverse a circular linked list starting from head and stop after one full cycle.

DSA C++

Node* current = head;
do {
    std::cout << current->data << " -> ";
    current = [1];
} while (current != head);
std::cout << "null";

Drag options to blanks, or click blank then click option'

Acurrent->next

Bhead

Cnullptr

Dcurrent

Attempts:

3 left

💡 Hint

Common Mistakes

Using head traverses only the first node.

Using nullptr causes a null pointer dereference.

To move through the list, we update current to current->next each time.

3fill in blank

hard

Fix the error in the code to insert a new node after the head in a circular linked list.

DSA C++

Node* newNode = new Node(5);
newNode->next = head->next;
head->next = [1];

Drag options to blanks, or click blank then click option'

AnewNode

Bhead->next

Cnullptr

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning head->next to head causes a loop.

Assigning head->next to nullptr breaks the list.

We must link head's next to the new node to insert it after head.

4fill in blank

hard

Fill both blanks to create a function that checks if a circular linked list contains a value.

DSA C++

bool contains(Node* head, int value) {
    if (!head) return false;
    Node* current = head;
    do {
        if (current->data [1] value) return true;
        current = [2];
    } while (current != head);
    return false;
}

Drag options to blanks, or click blank then click option'

A==

B!=

Ccurrent->next

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Using != instead of == causes wrong condition.

Moving current to head checks only the first node.

We compare current data to value using == and move current to current->next.

5fill in blank

hard

Fill all three blanks to create a function that counts nodes in a circular linked list.

DSA C++

int countNodes(Node* head) {
    if (!head) return 0;
    int count = 0;
    Node* current = [1];
    do {
        count [2] 1;
        current = [3];
    } while (current != head);
    return count;
}

Drag options to blanks, or click blank then click option'

Ahead

B+=

Ccurrent->next

Dnullptr

Attempts:

3 left

💡 Hint

Common Mistakes

Starting current at nullptr causes no counting.

Using = instead of += does not increment count properly.

Start from head, increment count by 1 each step, and move to next node until back to head.

Practice

1. What is a key advantage of using a circular linked list over a singly linked list?

easy

A. It prevents duplicate elements

B. It uses less memory than a singly linked list

C. It automatically sorts the elements

D. It allows continuous traversal from any node without stopping

Solution

1. Step 1: Understand traversal in singly linked list

   A singly linked list ends at the last node which points to null, so traversal stops there.

2. Step 2: Understand traversal in circular linked list

   In a circular linked list, the last node points back to the first node, allowing continuous traversal from any node.

3. Final Answer:

   It allows continuous traversal from any node without stopping -> Option D

4. Quick Check:

   Continuous traversal = Advantage of circular linked list [OK]

Hint: Circular lists loop back to start, enabling endless traversal [OK]

Common Mistakes:

• Thinking circular lists use less memory
• Assuming circular lists sort elements automatically
• Believing circular lists prevent duplicates

2. Which of the following is the correct way to make a singly linked list node point to itself in C++ to form a circular linked list?

easy

A. node->next = node;

B. node->next = nullptr;

C. node->next = head;

D. node->next = NULL;

Solution

1. Step 1: Understand node pointing in circular linked list

   For a single node circular list, the node's next pointer must point to itself to form a loop.

2. Step 2: Check the options

   node->next = node; sets node->next = node, correctly making the node point to itself.

3. Final Answer:

   node->next = node; -> Option A

4. Quick Check:

   Self-pointing node = node->next = node [OK]

Hint: Self-loop means node points to itself with node->next = node [OK]

Common Mistakes:

• Using nullptr or NULL breaks the circular link
• Setting next to head without defining head
• Confusing NULL and node pointer

3. Consider the following C++ code snippet for a circular linked list traversal:

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

void printList(Node* head) {
  Node* temp = head;
  if (head != nullptr) {
    do {
      std::cout << temp->data << " -> ";
      temp = temp->next;
    } while (temp != head);
  }
  std::cout << "null" << std::endl;
}

If the list has nodes with data 10, 20, 30 linked circularly, what will be the output of printList(head)?

medium

A. 10 -> 20 -> 30 -> 30 -> null

B. 10 -> 20 -> 30 -> null

C. 10 -> 20 -> 30 -> 10 -> 20 -> 30 -> null

D. null

Solution

1. Step 1: Understand the traversal loop

   The do-while loop prints current node data, then moves to next node, stopping when it reaches head again.

2. Step 2: Trace the output for nodes 10, 20, 30

   It prints 10, then 20, then 30, then stops because next is head again.

3. Final Answer:

   10 -> 20 -> 30 -> null -> Option B

4. Quick Check:

   One full cycle print = 10 -> 20 -> 30 -> null [OK]

Hint: do-while prints once per node until back to head [OK]

Common Mistakes:

• Thinking it prints infinitely
• Confusing do-while with while loop
• Missing the stopping condition temp == head

4. The following code attempts to insert a new node at the end of a circular linked list but causes an infinite loop. What is the error?

void insertEnd(Node*& head, int val) {
  Node* newNode = new Node{val, nullptr};
  if (!head) {
    head = newNode;
    return;
  }
  Node* temp = head;
  while (temp->next != nullptr) {
    temp = temp->next;
  }
  temp->next = newNode;
  newNode->next = head;
}

medium

A. The newNode is not allocated with new keyword

B. The newNode->next should be nullptr, not head

C. The while loop condition should check for temp->next != head, not nullptr

D. The head pointer is not updated after insertion

Solution

1. Step 1: Analyze the while loop condition

   In a circular linked list, last node's next points to head, not nullptr, so checking for nullptr causes infinite loop.

2. Step 2: Correct the condition to stop at last node

   The condition should be temp->next != head to stop at the last node before insertion.

3. Final Answer:

   The while loop condition should check for temp->next != head, not nullptr -> Option C

4. Quick Check:

   Loop stops at last node by checking next != head [OK]

Hint: In circular list, last node points to head, not nullptr [OK]

Common Mistakes:

• Using nullptr in loop condition for circular list
• Setting newNode->next to nullptr breaking circularity
• Not updating head when list is empty

5. Which real-world scenario best fits the use of a circular linked list?

hard

A. Implementing a music playlist that loops songs continuously

B. Storing a sorted list of unique user IDs

C. Managing a stack of undo operations

D. Representing a binary search tree for fast lookup

Solution

1. Step 1: Understand circular linked list use cases

   Circular linked lists are ideal for scenarios needing continuous looping through elements without stopping.

2. Step 2: Match options to use cases

   A music playlist that loops songs continuously fits perfectly because after the last song, it returns to the first.

3. Final Answer:

   Implementing a music playlist that loops songs continuously -> Option A

4. Quick Check:

   Continuous looping = music playlist use case [OK]

Hint: Continuous looping fits circular linked list use cases [OK]

Common Mistakes:

• Choosing sorted list which needs order, not circularity
• Confusing stack with linked list type
• Mixing tree structures with linked lists