Circular vs Linear Linked List Key Difference in DSA Go - Interactive Comparison Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if a linked list is circular by comparing the next pointer of the last node.

DSA Go

func isCircular(head *Node) bool {
    if head == nil {
        return false
    }
    current := head
    for current.next != nil {
        current = current.next
    }
    return current.next == [1]
}

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

Ahead

Bnil

Ccurrent

Dhead.next

Attempts:

3 left

💡 Hint

Common Mistakes

Checking if current.next == nil which is true for linear lists, not circular.

Comparing current.next to current instead of head.

In a circular linked list, the last node points back to the head node, so current.next == head is true.

2fill in blank

medium

Complete the code to insert a new node at the end of a circular linked list.

DSA Go

func insertEndCircular(head *Node, data int) *Node {
    newNode := &Node{data: data}
    if head == nil {
        newNode.next = newNode
        return newNode
    }
    current := head
    for current.next != [1] {
        current = current.next
    }
    current.next = newNode
    newNode.next = head
    return head
}

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

Anil

Bcurrent

CnewNode

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Using nil to detect the last node, which applies to linear lists only.

Setting newNode.next to nil instead of head.

In a circular linked list, the last node points back to the head, so we loop until current.next == head.

3fill in blank

hard

Fix the error in the code that tries to detect if a linked list is linear or circular by checking the next pointer of the last node.

DSA Go

func isLinear(head *Node) bool {
    if head == nil {
        return true
    }
    current := head
    for current.next != [1] {
        current = current.next
    }
    return current.next == nil
}

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

Acurrent

Bhead

Cnil

Dhead.next

Attempts:

3 left

💡 Hint

Common Mistakes

Using head to detect the end, which is for circular lists.

Looping infinitely by not checking for nil.

In a linear linked list, the last node's next pointer is nil. The loop should stop when current.next == nil.

4fill in blank

hard

Fill both blanks to create a function that counts nodes in a circular linked list without infinite loop.

DSA Go

func countNodesCircular(head *Node) int {
    if head == nil {
        return 0
    }
    count := 1
    current := head.next
    for current != [1] {
        count++
        current = current.[2]
    }
    return count
}

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

Ahead

Bnil

Cnext

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Using nil to stop the loop in a circular list causes infinite loop.

Using prev pointer which may not exist in singly linked lists.

We stop counting when current reaches head again. We move to the next node each iteration.

5fill in blank

hard

Fill all three blanks to create a function that converts a linear linked list into a circular linked list.

DSA Go

func makeCircular(head *Node) *Node {
    if head == nil {
        return nil
    }
    current := head
    for current.[1] != [2] {
        current = current.next
    }
    current.[3] = head
    return head
}

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

Anext

Bnil

Cprev

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev pointer which may not exist.

Setting current.next to nil instead of head.

We traverse until current.next is nil (end of linear list), then set current.next to head to make it circular.

Practice

1. What is the main difference between a circular linked list and a linear linked list?

easy

A. Circular linked lists do not have a head node.

B. In a linear linked list, the last node points back to the first node, forming a circle.

C. Both circular and linear linked lists have their last node pointing to null.

D. In a circular linked list, the last node points back to the first node, forming a circle.

Solution

1. Step 1: Understand the last node pointer in linear linked list

   In a linear linked list, the last node points to null, indicating the end of the list.

2. Step 2: Understand the last node pointer in circular linked list

   In a circular linked list, the last node points back to the first node, creating a loop or circle.

3. Final Answer:

   In a circular linked list, the last node points back to the first node, forming a circle. -> Option D

4. Quick Check:

   Last node points to first node = Circular linked list [OK]

Hint: Last node points to first node only in circular lists [OK]

Common Mistakes:

• Confusing last node pointer in linear and circular lists
• Thinking circular lists end with null
• Assuming circular lists have no head node

2. Which of the following is the correct way to check if a linked list is circular in Go?

easy

A. if last.next == nil { return true } else if last.next == head { return false }

B. if head == nil { return true } else if last.next == nil { return true }

C. if head == nil { return false } else if head.next == nil { return false } else if last.next == head { return true }

D. if head.next == nil { return true } else if last.next == nil { return false }

Solution

1. Step 1: Check if list is empty or has one node

   If head is nil or head.next is nil, list cannot be circular, so return false.

2. Step 2: Check if last node points back to head

   If last.next equals head, the list is circular, so return true.

3. Final Answer:

   if head == nil { return false } else if head.next == nil { return false } else if last.next == head { return true } -> Option C

4. Quick Check:

   Last node points to head means circular [OK]

Hint: Check last.next == head to confirm circular list [OK]

Common Mistakes:

• Returning true when list is empty
• Checking last.next == nil for circularity
• Confusing conditions for circular check

3. Consider the following Go code snippet for a circular linked list:

type Node struct {
    data int
    next *Node
}

func printList(head *Node) {
    if head == nil {
        fmt.Println("Empty list")
        return
    }
    current := head
    for {
        fmt.Print(current.data, " -> ")
        current = current.next
        if current == head {
            break
        }
    }
    fmt.Println("null")
}

func main() {
    n1 := &Node{data: 1}
    n2 := &Node{data: 2}
    n3 := &Node{data: 3}
    n1.next = n2
    n2.next = n3
    n3.next = n1
    printList(n1)
}

What will be the output?

medium

A. 1 -> 2 -> 3 -> null

B. 1 -> 2 -> 3 -> 1 -> 2 -> 3 -> ... (infinite loop)

C. Empty list

D. 1 -> 2 -> 3

Solution

1. Step 1: Understand the circular linked list structure

   Nodes 1, 2, 3 are linked circularly: last node points back to first node.

2. Step 2: Trace the printList function loop

   Loop prints current.data and moves to next node until current equals head again, then breaks.

3. Final Answer:

   1 -> 2 -> 3 -> null -> Option A

4. Quick Check:

   Loop stops when current == head, so no infinite loop [OK]

Hint: Loop breaks when current returns to head in circular list [OK]

Common Mistakes:

• Assuming infinite loop without break
• Printing 'Empty list' incorrectly
• Missing 'null' at end of output

4. The following Go code tries to detect if a linked list is circular but has a bug:

func isCircular(head *Node) bool {
    current := head
    for current != nil {
        if current.next == head {
            return true
        }
        current = current.next
    }
    return false
}

What is the bug in this code?

medium

A. It may cause infinite loop if list has a cycle not pointing to head.

B. It does not handle empty list (head == nil) case.

C. It incorrectly returns true for linear lists.

D. It uses wrong comparison operator for pointers.

Solution

1. Step 1: Analyze the loop condition and pointer movement

   The loop moves current until current is nil, checking if current.next == head.

2. Step 2: Identify the bug with cycles not pointing to head

   If the list has a cycle but not pointing to head, current will never be nil, causing infinite loop.

3. Final Answer:

   It may cause infinite loop if list has a cycle not pointing to head. -> Option A

4. Quick Check:

   Cycle detection needs more robust method than this [OK]

Hint: Cycle not pointing to head causes infinite loop here [OK]

Common Mistakes:

• Ignoring infinite loop possibility
• Assuming only head cycles exist
• Not checking for nil head

5. You have a linked list where the last node points back to the third node (not the head). Which statement is true about this list?

hard

A. It is a linear linked list because the last node does not point to head.

B. It is neither circular nor linear linked list.

C. It is a circular linked list because it has a cycle.

D. It is a doubly linked list.

Solution

1. Step 1: Recall definition of circular linked list

   A circular linked list specifically has its last node pointing back to the head (first node), forming a complete circle.

2. Step 2: Analyze the given list

   The last node points to the third node, creating a cycle but not pointing to head, so not circular. Linear lists end with null (no cycle). Thus, neither.

3. Final Answer:

   It is neither circular nor linear linked list. -> Option B

4. Quick Check:

   Circular requires last -> head specifically [OK]

Hint: Circular LL requires last -> head; other cycles != circular LL [OK]

Common Mistakes:

• Thinking any cycle makes it circular LL
• Confusing with doubly linked list
• Thinking it's linear despite cycle