Create a Circular Singly Linked List in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Circular Singly Linked List after Insertions

What is the printed state of the circular singly linked list after inserting nodes with values 10, 20, and 30 in that order?

DSA Go

package main

import "fmt"

type Node struct {
    data int
    next *Node
}

type CircularSinglyLinkedList struct {
    head *Node
}

func (list *CircularSinglyLinkedList) Insert(value int) {
    newNode := &Node{data: value}
    if list.head == nil {
        list.head = newNode
        newNode.next = newNode
        return
    }
    temp := list.head
    for temp.next != list.head {
        temp = temp.next
    }
    temp.next = newNode
    newNode.next = list.head
}

func (list *CircularSinglyLinkedList) Print() {
    if list.head == nil {
        fmt.Println("List is empty")
        return
    }
    temp := list.head
    for {
        fmt.Printf("%d -> ", temp.data)
        temp = temp.next
        if temp == list.head {
            break
        }
    }
    fmt.Println("(head)")
}

func main() {
    list := CircularSinglyLinkedList{}
    list.Insert(10)
    list.Insert(20)
    list.Insert(30)
    list.Print()
}

A 10 -> 20 -> 30 -> (head)

B 10 -> 20 -> (head)

C 30 -> 20 -> 10 -> (head)

D List is empty

💡 Hint

Remember that each new node is added at the end and points back to the head.

Nodes are inserted at the end. After inserting 10, 20, and 30, the list prints in insertion order ending back at head.

❓ Predict Output

intermediate

Output after Deleting Head Node in Circular Singly Linked List

Given a circular singly linked list with nodes 5 -> 15 -> 25 -> (head), what is the printed list after deleting the head node (value 5)?

DSA Go

package main

import "fmt"

type Node struct {
    data int
    next *Node
}

type CircularSinglyLinkedList struct {
    head *Node
}

func (list *CircularSinglyLinkedList) Insert(value int) {
    newNode := &Node{data: value}
    if list.head == nil {
        list.head = newNode
        newNode.next = newNode
        return
    }
    temp := list.head
    for temp.next != list.head {
        temp = temp.next
    }
    temp.next = newNode
    newNode.next = list.head
}

func (list *CircularSinglyLinkedList) DeleteHead() {
    if list.head == nil {
        return
    }
    if list.head.next == list.head {
        list.head = nil
        return
    }
    temp := list.head
    for temp.next != list.head {
        temp = temp.next
    }
    temp.next = list.head.next
    list.head = list.head.next
}

func (list *CircularSinglyLinkedList) Print() {
    if list.head == nil {
        fmt.Println("List is empty")
        return
    }
    temp := list.head
    for {
        fmt.Printf("%d -> ", temp.data)
        temp = temp.next
        if temp == list.head {
            break
        }
    }
    fmt.Println("(head)")
}

func main() {
    list := CircularSinglyLinkedList{}
    list.Insert(5)
    list.Insert(15)
    list.Insert(25)
    list.DeleteHead()
    list.Print()
}

A 15 -> 25 -> (head)

B 5 -> 15 -> 25 -> (head)

C 25 -> 15 -> (head)

D List is empty

💡 Hint

Deleting head means the second node becomes the new head.

After deleting the head (5), the new head is 15 and the list loops back to it.

🔧 Debug

advanced

Identify the Bug in Circular Singly Linked List Insertion

What error will occur when running this insertion code for a circular singly linked list?

DSA Go

func (list *CircularSinglyLinkedList) Insert(value int) {
    newNode := &Node{data: value}
    if list.head == nil {
        list.head = newNode
        newNode.next = nil
        return
    }
    temp := list.head
    for temp.next != list.head {
        temp = temp.next
    }
    temp.next = newNode
    newNode.next = list.head
}

A No error; the code works correctly

B The code will cause a runtime panic due to nil pointer dereference

C The code will insert nodes at the head instead of the tail

D The list will become non-circular because newNode.next is set to nil

💡 Hint

Check what happens when the list has only one node.

Setting newNode.next to nil breaks the circular link, making the list non-circular.

❓ Predict Output

advanced

Output after Traversing Circular Singly Linked List with One Node

What is the output when printing a circular singly linked list with a single node containing value 42?

DSA Go

package main

import "fmt"

type Node struct {
    data int
    next *Node
}

type CircularSinglyLinkedList struct {
    head *Node
}

func (list *CircularSinglyLinkedList) Insert(value int) {
    newNode := &Node{data: value}
    if list.head == nil {
        list.head = newNode
        newNode.next = newNode
        return
    }
    temp := list.head
    for temp.next != list.head {
        temp = temp.next
    }
    temp.next = newNode
    newNode.next = list.head
}

func (list *CircularSinglyLinkedList) Print() {
    if list.head == nil {
        fmt.Println("List is empty")
        return
    }
    temp := list.head
    for {
        fmt.Printf("%d -> ", temp.data)
        temp = temp.next
        if temp == list.head {
            break
        }
    }
    fmt.Println("(head)")
}

func main() {
    list := CircularSinglyLinkedList{}
    list.Insert(42)
    list.Print()
}

A 42 -> 42 -> (head)

B 42 -> (head)

C List is empty

D Runtime error due to infinite loop

💡 Hint

A single node points to itself in a circular list.

The single node points back to itself, so it prints once then stops.

🧠 Conceptual

expert

Number of Nodes in Circular Singly Linked List after Multiple Insertions and Deletions

Starting with an empty circular singly linked list, you insert nodes with values 1, 2, 3, 4, and 5 in order. Then you delete the head node twice. How many nodes remain in the list?

A 4

B 2

C 3

D 5

💡 Hint

Each deletion removes one node from the list.

After inserting 5 nodes and deleting head twice, 3 nodes remain.

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