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

Create a Circular Singly Linked List

📖 Scenario: Imagine you are building a simple music playlist app. The songs play in a loop, so after the last song, it goes back to the first song automatically. To do this, you need a circular list where the last song points back to the first.

🎯 Goal: You will create a circular singly linked list in C that holds three songs. Each node will have a song name and a pointer to the next song. The last song will point back to the first, making the list circular.

📋 What You'll Learn

Define a struct Node with a char* for the song name and a struct Node* for the next pointer

Create three nodes with song names: "Song1", "Song2", and "Song3"

Link the nodes so that the last node points back to the first node

Print the song names in the circular list once, starting from the first node

💡 Why This Matters

🌍 Real World

Circular linked lists are used in music players, round-robin schedulers, and games where items repeat in a loop.

💼 Career

Understanding circular linked lists helps in system programming, embedded systems, and software that requires cyclic data processing.

1

Define the Node structure and create three nodes

Define a struct Node with a char* song and a struct Node* next. Then create three nodes called node1, node2, and node3 with song names "Song1", "Song2", and "Song3" respectively.

DSA C

# Define struct Node and create node1, node2, node3 with songs
// Your code here

Hint

Use malloc to create nodes and assign song names using the arrow operator ->.

2

Link the nodes to form a circular list

Link the nodes by setting node1->next to node2, node2->next to node3, and node3->next back to node1 to make the list circular.

DSA C

#include 
#include 

struct Node {
    char* song;
    struct Node* next;
};

int main() {
    struct Node* node1 = (struct Node*)malloc(sizeof(struct Node));
    struct Node* node2 = (struct Node*)malloc(sizeof(struct Node));
    struct Node* node3 = (struct Node*)malloc(sizeof(struct Node));

    node1->song = "Song1";
    node2->song = "Song2";
    node3->song = "Song3";

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

    return 0;
}

Hint

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

3

Traverse the circular list once and print song names

Create a struct Node* variable called current and set it to node1. Use a do-while loop to print current->song and move current to current->next. Stop the loop when current is node1 again.

DSA C

#include 
#include 

struct Node {
    char* song;
    struct Node* next;
};

int main() {
    struct Node* node1 = (struct Node*)malloc(sizeof(struct Node));
    struct Node* node2 = (struct Node*)malloc(sizeof(struct Node));
    struct Node* node3 = (struct Node*)malloc(sizeof(struct Node));

    node1->song = "Song1";
    node2->song = "Song2";
    node3->song = "Song3";

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

    // Traverse and print songs once
    // Your code here

    return 0;
}

Hint

Use a do-while loop to print each song and move to the next node until you reach the first node again.

4

Print the circular list output

Run the program to print the song names in order: Song1, Song2, and Song3, each on its own line.

DSA C

#include 
#include 

struct Node {
    char* song;
    struct Node* next;
};

int main() {
    struct Node* node1 = (struct Node*)malloc(sizeof(struct Node));
    struct Node* node2 = (struct Node*)malloc(sizeof(struct Node));
    struct Node* node3 = (struct Node*)malloc(sizeof(struct Node));

    node1->song = "Song1";
    node2->song = "Song2";
    node3->song = "Song3";

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

    struct Node* current = node1;
    do {
        printf("%s\n", current->song);
        current = current->next;
    } while (current != node1);

    return 0;
}

// Run the program to see the output

Hint

Make sure your program prints each song name on its own line exactly as shown.

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