Create a Circular Singly Linked List in DSA Go - 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 will create a circular singly linked list where each node points to the next song, and the last song points back to the first.

🎯 Goal: You will create a circular singly linked list in Go with three songs. Then, you will print the playlist in order to see the circular connection.

📋 What You'll Learn

Define a Node struct with data and next fields

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

Link the nodes so that the last node points back to the first node, making the list circular

Print the circular linked list by traversing exactly three nodes to show the loop

💡 Why This Matters

🌍 Real World

Circular linked lists are useful in applications like music playlists, round-robin scheduling, and games where the sequence repeats endlessly.

💼 Career

Understanding circular linked lists helps in software development roles that involve data structure design, memory management, and real-time systems.

1

Define the Node struct and create three nodes

Define a struct called Node with a data field of type string and a next field of type *Node. Then create three variables called node1, node2, and node3 of type Node with data values "Song1", "Song2", and "Song3" respectively.

DSA Go

package main

import "fmt"

type Node struct {
    data string
    next *Node
}

func main() {
    // Create node1 with data "Song1"
    // Create node2 with data "Song2"
    // Create node3 with data "Song3"
}

Hint

Start by defining the Node struct with two fields. Then create three nodes with the given song names.

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 to &node1 to make the list circular.

DSA Go

package main

import "fmt"

type Node struct {
    data string
    next *Node
}

func main() {
    node1 := Node{data: "Song1"}
    node2 := Node{data: "Song2"}
    node3 := Node{data: "Song3"}
    // Link node1.next to &node2
    // Link node2.next to &node3
    // Link node3.next to &node1
}

Hint

Set the next field of each node to point to the next node, and the last node back to the first.

3

Create a variable to start traversal

Create a variable called current and set it to the address of node1 to start traversing the circular list from the first node.

DSA Go

package main

import "fmt"

type Node struct {
    data string
    next *Node
}

func main() {
    node1 := Node{data: "Song1"}
    node2 := Node{data: "Song2"}
    node3 := Node{data: "Song3"}

    node1.next = &node2
    node2.next = &node3
    node3.next = &node1

    // Create variable current and set it to &node1
}

Hint

Use a pointer variable current to start at the first node for traversal.

4

Print the circular linked list nodes

Use a for loop that runs exactly 3 times. Inside the loop, print the data of the current node, then move current to current.next. This will print all three songs showing the circular list.

DSA Go

package main

import "fmt"

type Node struct {
    data string
    next *Node
}

func main() {
    node1 := Node{data: "Song1"}
    node2 := Node{data: "Song2"}
    node3 := Node{data: "Song3"}

    node1.next = &node2
    node2.next = &node3
    node3.next = &node1

    current := &node1

    // Use a for loop to print data of current node 3 times
}

Hint

Loop exactly 3 times to print each song's data, moving current to the next node each time.

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. Nodes are stored in sorted order automatically.

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, nodes have only one pointer. Unlike arrays, nodes are linked by pointers, not indices.

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 = D [OK]

Hint: Last node points to head in circular singly linked list [OK]

Common Mistakes:

• Confusing circular singly linked list with doubly linked list
• Thinking nodes have two pointers
• Assuming nodes are stored in arrays

2. Which of the following Go code snippets correctly initializes a circular singly linked list with one node containing value 10?

easy

A. node := &Node{data: 10}; node.next = node

B. node := Node{data: 10}; node.next = nil

C. node := &Node{data: 10, next: nil}

D. node := &Node{data: 10}; node.next = nil

Solution

1. Step 1: Create a node pointer and assign data

   Using &Node creates a pointer to a Node struct with data 10.

2. Step 2: Make the node point to itself

   Setting node.next = node creates a circular link for a single node list.

3. Final Answer:

   node := &Node{data: 10}; node.next = node -> Option A

4. Quick Check:

   Single node points to itself = C [OK]

Hint: Single node's next points to itself for circular list [OK]

Common Mistakes:

• Setting next to nil breaks circular property
• Not using pointer for node
• Confusing struct initialization syntax

3. Given the following Go code, what will be printed?

package main
import "fmt"

type Node struct {
    data int
    next *Node
}

func main() {
    head := &Node{data: 1}
    second := &Node{data: 2}
    third := &Node{data: 3}

    head.next = second
    second.next = third
    third.next = head

    current := head
    for i := 0; i < 5; i++ {
        fmt.Print(current.data, " ")
        current = current.next
    }
}

medium

A. 1 2 3 1 1

B. 1 2 3 3 3

C. 1 2 3 1 2

D. 1 2 3 2 3

Solution

1. Step 1: Understand the circular list structure

   Nodes 1 -> 2 -> 3 -> back to 1, forming a circle.

2. Step 2: Trace the loop printing 5 nodes

   Prints: 1, then 2, then 3, then back to 1, then 2.

3. Final Answer:

   1 2 3 1 2 -> Option C

4. Quick Check:

   Loop prints nodes in circle = A [OK]

Hint: Follow next pointers in circle for 5 steps [OK]

Common Mistakes:

• Assuming list ends after 3 nodes
• Not looping back to head
• Miscounting loop iterations

4. Identify the error in this Go code that tries to create a circular singly linked list with two nodes:

package main

type Node struct {
    data int
    next *Node
}

func main() {
    first := &Node{data: 1}
    second := &Node{data: 2}

    first.next = second
    second.next = nil

    // Make it circular
    second.next = first
}

medium

A. No error, code correctly creates circular list

B. second.next is set to nil then overwritten, unnecessary step

C. second.next is set to nil before setting to first, redundant but no error

D. Missing initialization of first.next before assigning second

Solution

1. Step 1: Analyze the assignments to second.next

   Initially second.next is set to nil, then immediately overwritten to first.

2. Step 2: Identify redundancy

   Setting second.next to nil is unnecessary since it is overwritten right after.

3. Final Answer:

   second.next is set to nil then overwritten, unnecessary step -> Option B

4. Quick Check:

   Redundant assignment detected = B [OK]

Hint: Avoid redundant pointer assignments in circular list [OK]

Common Mistakes:

• Thinking nil assignment causes error
• Ignoring redundant code
• Confusing order of pointer assignments

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 Go code snippets correctly performs this insertion?

hard

A. newNode := &Node{data: 4}
current := head
for current.next != nil {
current = current.next
}
current.next = newNode
newNode.next = head

B. newNode := &Node{data: 4, next: head}
head.next = newNode

C. newNode := &Node{data: 4}
newNode.next = head
head.next = newNode

D. newNode := &Node{data: 4}
current := head
for current.next != head {
current = current.next
}
current.next = newNode
newNode.next = head

Solution

1. Step 1: Traverse to last node before head

   Loop until current.next == head to find last node in circular list.

2. Step 2: Insert new node after last node and link back to head

   Set current.next = newNode and newNode.next = head to maintain circularity.

3. Final Answer:

   Traverse to last node, link new node, then link new node back to head -> Option D

4. Quick Check:

   Proper insertion at end keeps circle intact = A [OK]

Hint: Find last node where next is head, insert new node there [OK]

Common Mistakes:

• Using nil instead of head to find last node
• Not linking new node back to head
• Incorrectly changing head pointer