Create a Circular Singly Linked List in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a node structure for a circular singly linked list.

DSA C

struct Node {
    int data;
    struct Node* [1];
};

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

Aprev

Bnext

Cchild

Dlink

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' which is for doubly linked lists.

Using 'child' or 'link' which are not standard names here.

The pointer to the next node in a singly linked list is commonly named 'next'.

2fill in blank

medium

Complete the code to create a new node and assign data to it.

DSA C

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = [1];

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

ANULL

Bvalue

C0

Ddata

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning NULL or 0 instead of the actual data.

Using an undefined variable like 'value'.

We assign the input 'data' value to the new node's data field.

3fill in blank

hard

Fix the error in linking the new node to itself for a single-node circular list.

DSA C

newNode->next = [1];

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

ANULL

Bhead

CnewNode

Dtemp

Attempts:

3 left

💡 Hint

Common Mistakes

Setting next to NULL breaks the circular property.

Using 'head' or 'temp' without initialization.

For a single-node circular list, the node's next pointer should point to itself.

4fill in blank

hard

Fill both blanks to insert a new node at the end of a circular singly linked list.

DSA C

temp = head;
while (temp->[1] != head) {
    temp = temp->[2];
}
temp->next = newNode;
newNode->next = head;

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

Anext

Bprev

Clink

Dchild

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' which is for doubly linked lists.

Using different pointer names in the loop causing errors.

To traverse the circular list, we follow the 'next' pointers until we reach the head again.

5fill in blank

hard

Fill all three blanks to create a function that inserts a node at the end of a circular singly linked list.

DSA C

void insertEnd(struct Node** head, int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = [1];
    if (*head == NULL) {
        newNode->next = [2];
        *head = newNode;
    } else {
        struct Node* temp = *head;
        while (temp->next != *head) {
            temp = temp->next;
        }
        temp->next = newNode;
        newNode->next = [3];
    }
}

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

Adata

BnewNode

C*head

DNULL

Attempts:

3 left

💡 Hint

Common Mistakes

Not setting newNode->next correctly for empty list.

Linking newNode->next to NULL instead of head.

We assign 'data' to newNode->data, point newNode->next to itself if list is empty, and link newNode->next to head otherwise.

Practice

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

easy

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

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

C. It uses an array internally to store nodes.

D. The list ends with a null pointer indicating the end.

Solution

1. Step 1: Understand the pointer structure in 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 regular singly linked list

   Regular singly linked lists end with a null pointer, while circular ones loop back to the start.

3. Final Answer:

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

4. Quick Check:

   Circular list last node points to head = C [OK]

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

Common Mistakes:

• Thinking circular list ends with null pointer
• Confusing circular singly linked list with doubly linked list
• Assuming nodes have two pointers in singly linked list

2. Which of the following is the correct way to initialize a circular singly linked list with one node in C?

easy

A. node->next = head->next;

B. node->next = NULL;

C. node->next = node;

D. node->next = 0;

Solution

1. Step 1: Understand initialization of single node circular list

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

2. Step 2: Check each option

   node->next = node; sets node->next = node, correctly creating a self-loop. Others either set null or incorrect pointers.

3. Final Answer:

   node->next = node; -> Option C

4. Quick Check:

   Single node points to itself = A [OK]

Hint: Single node circular list points to itself [OK]

Common Mistakes:

• Setting next pointer to NULL instead of self
• Using uninitialized pointers
• Confusing NULL with 0 in pointer context

3. Consider the following C code snippet that creates a circular singly linked list with three nodes. What will be the output of the print loop?

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

int main() {
  Node n1 = {1, NULL};
  Node n2 = {2, NULL};
  Node n3 = {3, NULL};

  n1.next = &n2;
  n2.next = &n3;
  n3.next = &n1;  // circular link

  Node* temp = &n1;
  int count = 0;
  while (count < 5) {
    printf("%d ", temp->data);
    temp = temp->next;
    count++;
  }
  return 0;
}

medium

A. 1 2 3 3 3

B. 1 2 3 2 3

C. 1 2 3 1 1

D. 1 2 3 1 2

Solution

1. Step 1: Trace the linked list nodes and their next pointers

   n1 points to n2, n2 points to n3, n3 points back to n1, forming a circle: 1 -> 2 -> 3 -> 1 ...

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

   Print order: 1 (n1), 2 (n2), 3 (n3), 1 (n1 again), 2 (n2 again).

3. Final Answer:

   1 2 3 1 2 -> Option D

4. Quick Check:

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

Hint: Follow next pointers in circle for given count [OK]

Common Mistakes:

• Stopping after 3 nodes instead of 5
• Not following circular link back to first node
• Confusing node data values

4. The following code attempts to create a circular singly linked list with two nodes. What is the error?

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

int main() {
  Node* n1 = malloc(sizeof(Node));
  Node* n2 = malloc(sizeof(Node));
  n1->data = 10;
  n2->data = 20;
  n1->next = n2;
  n2->next = NULL;  // mistake here
  return 0;
}

medium

A. Memory allocation is missing for nodes.

B. n2->next should point to n1 to make the list circular.

C. Data values are not initialized correctly.

D. n1->next should be NULL instead of n2.

Solution

1. Step 1: Identify the circular link requirement

   In a circular singly linked list, the last node's next pointer must point back to the first node.

2. Step 2: Check the code's next pointers

   n1->next points to n2, but n2->next is NULL, breaking the circle. It should point to n1.

3. Final Answer:

   n2->next should point to n1 to make the list circular. -> Option B

4. Quick Check:

   Last node next points to head = D [OK]

Hint: Last node's next must link to first node [OK]

Common Mistakes:

• Setting last node next to NULL instead of head
• Forgetting to allocate memory for nodes
• Mixing up which node points where

5. You want to insert a new node with data 5 at the end of an existing circular singly linked list. The list currently has nodes 1 -> 2 -> 3 -> (back to 1). Which steps correctly insert the new node to maintain the circular structure?

hard

A. Create new node; set new_node->next = head; find last node; set last_node->next = new_node;

B. Create new node; set new_node->next = NULL; find last node; set last_node->next = new_node;

C. Create new node; set new_node->next = last_node; set head = new_node;

D. Create new node; set new_node->next = head->next; set head->next = new_node;

Solution

1. Step 1: Create new node and link it to head

   The new node's next pointer must point to the head to keep the circle intact.

2. Step 2: Find the last node and update its next pointer

   Traverse the list to find the last node (which points to head), then set last_node->next to new_node.

3. Final Answer:

   Create new node; set new_node->next = head; find last node; set last_node->next = new_node; -> Option A

4. Quick Check:

   New node next = head, last node next = new node = A [OK]

Hint: New node next points to head; last node next points to new node [OK]

Common Mistakes:

• Setting new node next to NULL breaks circularity
• Not updating last node's next pointer
• Confusing head and last node pointers