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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new node with given data.

DSA Go

node := &Node{data: [1], next: nil}

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

A5

Bvalue

Cdata

Dnode

Attempts:

3 left

💡 Hint

Common Mistakes

Using variable names instead of actual data value.

The new node must hold the actual data value, here 5.

2fill in blank

medium

Complete the code to link the new node to itself to form a circular list.

DSA Go

node.next = [1]

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

Anil

Bhead

Cnode

DnewNode

Attempts:

3 left

💡 Hint

Common Mistakes

Setting next to nil breaks circularity.

In a circular singly linked list with one node, the node points to itself.

3fill in blank

hard

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

DSA Go

newNode.next = head.next
head.next = [1]

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

Ahead

BnewNode

Cnode

Dnil

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning head instead of newNode breaks the list.

To insert newNode after head, head.next must point to newNode.

4fill in blank

hard

Fill both blanks to complete the function that creates a circular singly linked list with one node.

DSA Go

func createCircularList(data int) *Node {
    node := &Node{data: data, next: [1]
    [2] = node
    return node
}

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

Anode

Bnil

Chead

DnewNode

Attempts:

3 left

💡 Hint

Common Mistakes

Setting next to nil breaks circularity.

Not assigning head causes undefined reference.

The node's next points to itself, and head is assigned to node.

5fill in blank

hard

Fill all three blanks to complete the function that inserts a new node after head in the circular singly linked list.

DSA Go

func insertAfterHead(head *Node, data int) {
    newNode := &Node{data: [1], next: [2]
    head.next = [3]
}

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

Adata

Bhead.next

CnewNode

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up pointers causing broken links.

newNode holds data, points to head.next, and head.next is updated to newNode.

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