Linked List vs Array When to Choose Which in DSA Go - Interactive Comparison Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare an array of integers with 5 elements.

DSA Go

var numbers = [[1]]int{}

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

A5

B10

C3

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 or missing the size causes errors.

The code declares an array of 5 integers. The number inside the brackets specifies the size.

2fill in blank

medium

Complete the code to create a linked list node struct with an integer value and a pointer to the next node.

DSA Go

type Node struct {
    value int
    [1] *Node
}

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

Anext

Bprev

Clink

Dpointer

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' is for doubly linked lists, not singly linked.

The field 'next' points to the next node in the linked list.

3fill in blank

hard

Fix the error in the code to append a new node to the end of a singly linked list.

DSA Go

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

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

Alink

Bprev

Cnext

Dpointer

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' or other names causes errors.

The loop uses 'current.next' to traverse nodes until the end.

4fill in blank

hard

Fill both blanks to create a function that returns the length of a linked list.

DSA Go

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

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

Anil

B+=

C-=

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' instead of nil in loop condition.

Using '-=' instead of '+=' for count.

The loop runs until current is nil, counting nodes by incrementing count with '+='.

5fill in blank

hard

Fill all three blanks to create a function that inserts a new node at the beginning of a linked list.

DSA Go

func insertAtHead(head *Node, val int) *Node {
    newNode := &Node{value: [1]
    newNode.[2] = [3]
    return newNode
}

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

Aval

Bhead

Cnext

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up next and prev fields.

Not linking new node to existing list.

The new node's value is set to val, its next points to the current head, and then it becomes the new head.

Practice

1. Which data structure is better when you need fast random access to elements by index?

easy

A. Array

B. Linked List

C. Stack

D. Queue

Solution

1. Step 1: Understand random access in arrays

   Arrays store elements contiguously, so accessing any index is fast and direct.

2. Step 2: Compare with linked list access

   Linked lists require traversal from the start to reach an index, which is slower.

3. Final Answer:

   Array -> Option A

4. Quick Check:

   Fast random access = Array [OK]

Hint: For fast index access, choose arrays [OK]

Common Mistakes:

• Thinking linked lists provide fast random access
• Confusing stack or queue with random access
• Ignoring array's contiguous memory advantage

2. Which of the following is the correct way to declare an array of integers with 5 elements in Go?

easy

A. var arr [5]int

B. arr := []int{5}

C. var arr int[5]

D. arr := int[5]

Solution

1. Step 1: Recall Go array declaration syntax

   In Go, arrays are declared with var name [size]type, e.g., var arr [5]int.

2. Step 2: Check other options for errors

   arr := []int{5} declares a slice with one element 5, not an array of size 5. var arr int[5] syntax is invalid. arr := int[5] syntax is invalid.

3. Final Answer:

   var arr [5]int -> Option A

4. Quick Check:

   Go array syntax = var arr [5]int [OK]

Hint: Use var name [size]type for arrays in Go [OK]

Common Mistakes:

• Confusing slices with arrays
• Using incorrect syntax like int[5]
• Assuming shorthand always creates arrays

3. Consider the following Go code using a singly linked list. What will be printed after inserting 3 nodes with values 10, 20, 30 in that order?

package main
import "fmt"
type Node struct {
    value int
    next  *Node
}
func main() {
    head := &Node{value: 10}
    head.next = &Node{value: 20}
    head.next.next = &Node{value: 30}

    current := head
    for current != nil {
        fmt.Print(current.value, " -> ")
        current = current.next
    }
    fmt.Print("null")
}

medium

A. null

B. 30 -> 20 -> 10 -> null

C. 10 -> 20 -> 30 -> null

D. 10 -> 30 -> 20 -> null

Solution

1. Step 1: Trace node insertion order

   Nodes are linked as 10 -> 20 -> 30 in order, so head points to 10, next to 20, then 30.

2. Step 2: Trace print loop

   Loop prints current.value then moves to next until nil, printing 10 -> 20 -> 30 -> null.

3. Final Answer:

   10 -> 20 -> 30 -> null -> Option C

4. Quick Check:

   Linked list traversal prints nodes in insertion order [OK]

Hint: Traverse linked list from head to print in order [OK]

Common Mistakes:

• Assuming reverse order print
• Confusing next pointers
• Forgetting to print 'null' at end

4. The following Go code tries to insert a new node with value 15 after the head in a linked list. What is the bug?

package main
type Node struct {
    value int
    next  *Node
}
func main() {
    head := &Node{value: 10}
    head.next = &Node{value: 20}

    newNode := &Node{value: 15}
    newNode.next = head.next
    head = newNode
}

medium

A. Incorrect struct definition

B. The new node is not linked correctly; head pointer is overwritten

C. Missing initialization of newNode

D. No bug; code works fine

Solution

1. Step 1: Analyze pointer changes

   newNode.next points to head.next (20), but then head is set to newNode, losing original head node (10).

2. Step 2: Identify correct insertion

   To insert after head, should set head.next = newNode, not head = newNode.

3. Final Answer:

   The new node is not linked correctly; head pointer is overwritten -> Option B

4. Quick Check:

   Head pointer overwritten = bug [OK]

Hint: To insert after head, update head.next, not head [OK]

Common Mistakes:

• Overwriting head pointer instead of next
• Confusing insertion before vs after head
• Ignoring pointer updates needed

5. You need to store a large collection of elements where insertions and deletions happen frequently at unknown positions, but random access is rarely needed. Which data structure is best and why?

hard

A. Linked List, because it supports fast random access

B. Array, because it uses contiguous memory for fast access

C. Array, because it uses less memory than linked lists

D. Linked List, because it allows efficient insertions and deletions anywhere

Solution

1. Step 1: Understand insertion/deletion needs

   Frequent insertions/deletions at unknown positions are costly in arrays due to shifting elements.

2. Step 2: Compare linked list advantages

   Linked lists allow changing pointers to insert/delete nodes efficiently without shifting.

3. Step 3: Consider random access requirement

   Random access is rare, so linked list's slower access is acceptable.

4. Final Answer:

   Linked List, because it allows efficient insertions and deletions anywhere -> Option D

5. Quick Check:

   Frequent insert/delete unknown pos = Linked List [OK]

Hint: Choose linked list for frequent insert/delete at unknown spots [OK]

Common Mistakes:

• Choosing array for frequent insert/delete
• Confusing random access speed importance
• Ignoring memory overhead of linked lists