Stack Using Linked List vs Array Stack Trade-offs in DSA Go - Interactive Comparison Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to push an element onto an array-based stack.

DSA Go

func (s *ArrayStack) Push(value int) {
    if s.top == len(s.data) {
        s.data = append(s.data, [1])
    }
    s.data[s.top] = value
    s.top++
}

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

A0

B-1

Cnil

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Appending the actual value instead of a zero placeholder.

Appending nil which is invalid for int slices.

When the array is full, we append a zero value to extend it before assigning the new value.

2fill in blank

medium

Complete the code to pop an element from a linked list stack.

DSA Go

func (s *LinkedListStack) Pop() (int, bool) {
    if s.top == nil {
        return 0, false
    }
    value := s.top.value
    s.top = [1]
    return value, true
}

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

As.top

Bs.top.prev

Cnil

Ds.top.next

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev instead of next.

Setting top to nil prematurely.

To pop, we move the top pointer to the next node in the linked list.

3fill in blank

hard

Fix the error in the array stack's IsEmpty method.

DSA Go

func (s *ArrayStack) IsEmpty() bool {
    return [1]
}

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

As.top == 0

Blen(s.data) == 0

Cs.top == len(s.data)

Ds.data == nil

Attempts:

3 left

💡 Hint

Common Mistakes

Checking length of data slice instead of top index.

Comparing top to length of data slice incorrectly.

The stack is empty when the top index is zero, not when the data slice length is zero.

4fill in blank

hard

Fill both blanks to correctly initialize a linked list stack node and push it.

DSA Go

func (s *LinkedListStack) Push(value int) {
    node := &Node{value: value, [1]: s.top}
    s.top = [2]
}

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

Anext

Bprev

Cnode

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' instead of 'next' for the node link.

Not updating top to the new node.

The new node's next points to the current top, then top is updated to the new node.

5fill in blank

hard

Fill all three blanks to create a map of stack size and capacity and check if array stack is full.

DSA Go

sizes := map[string]int{"size": [1], "capacity": [2]

func (s *ArrayStack) IsFull() bool {
    return s.top [3] len(s.data)
}

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

Alen(s.data)

Bs.top

C==

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing top with length of data slice.

Using incorrect comparison operator in IsFull.

The array stack size is s.top, capacity is the length of its data slice, and IsFull checks if top equals data length.

Practice

1. Which of the following is a key advantage of using a linked list to implement a stack compared to using an array?

easy

A. Dynamic size without needing to resize

B. Faster access to elements by index

C. Uses less memory per element

D. Simpler syntax in Go

Solution

1. Step 1: Understand stack size behavior

   Array stacks have fixed size or need resizing, linked lists grow dynamically.

2. Step 2: Compare advantages

   Linked list stacks do not require resizing, so they handle dynamic size better.

3. Final Answer:

   Dynamic size without needing to resize -> Option A

4. Quick Check:

   Linked list stacks grow dynamically = B [OK]

Hint: Linked lists grow dynamically, arrays need resizing [OK]

Common Mistakes:

• Thinking arrays always use less memory
• Confusing access speed advantage
• Assuming syntax is simpler for linked lists

2. Which Go syntax correctly declares an array-based stack with capacity 5?

easy

A. stack := make([]int, 5)

B. stack := [5]int{}

C. var stack []int

D. var stack []int = [5]int{}

Solution

1. Step 1: Identify array declaration syntax

   In Go, arrays are declared as [size]type{}, e.g., [5]int{}.

2. Step 2: Check options

   stack := [5]int{} uses correct syntax for array with size 5 and int type.

3. Final Answer:

   stack := [5]int{} -> Option B

4. Quick Check:

   Array declaration = [5]int{} [OK]

Hint: Arrays use [size]type{}, slices use make() [OK]

Common Mistakes:

• Confusing slices with arrays
• Using make() for arrays
• Incorrect variable declaration syntax

3. Consider this Go code implementing a stack using an array:

type Stack struct {
  items [3]int
  top int
}

func (s *Stack) Push(val int) bool {
  if s.top == len(s.items) {
    return false
  }
  s.items[s.top] = val
  s.top++
  return true
}

func (s *Stack) Pop() (int, bool) {
  if s.top == 0 {
    return 0, false
  }
  s.top--
  return s.items[s.top], true
}

func main() {
  s := Stack{}
  s.Push(10)
  s.Push(20)
  s.Push(30)
  s.Push(40) // extra push
  val, ok := s.Pop()
  fmt.Println(val, ok)
}

What is the output?

medium

A. 20 true

B. 40 true

C. 30 true

D. 0 false

Solution

1. Step 1: Trace Push operations

   Push 10, 20, 30 succeed; Push 40 fails because stack is full (size 3).

2. Step 2: Trace Pop operation

   Pop returns last pushed value 30 and true.

3. Final Answer:

   30 true -> Option C

4. Quick Check:

   Last pushed valid value = 30 [OK]

Hint: Stack size limits extra pushes; pop returns last valid push [OK]

Common Mistakes:

• Assuming push always succeeds
• Thinking pop returns failed push value
• Confusing top index after push/pop

4. This Go code attempts to implement a linked list stack but has a bug:

type Node struct {
  value int
  next *Node
}

type Stack struct {
  head *Node
}

func (s *Stack) Push(val int) {
  newNode := &Node{value: val}
  newNode.next = s.head
  s.head = newNode
}

func (s *Stack) Pop() (int, bool) {
  if s.head == nil {
    return 0, false
  }
  val := s.head.value
  s.head = s.head.next
  return val, true
}

func main() {
  s := Stack{}
  s.Push(1)
  s.Push(2)
  s.Pop()
  s.Pop()
  s.Pop() // extra pop
}

What is the bug in this code?

medium

A. Extra pop returns false but is ignored, no bug

B. Push does not update the head pointer

C. Pop does not check for empty stack before accessing value

D. Node struct missing initialization of next pointer

Solution

1. Step 1: Analyze Pop safety check

   Pop checks if head is nil before accessing value, so no crash.

2. Step 2: Check extra pop behavior

   Extra pop returns (0, false), which is safe but ignored in main.

3. Final Answer:

   Extra pop returns false but is ignored, no bug -> Option A

4. Quick Check:

   Pop safe on empty stack = A [OK]

Hint: Check nil before pop; ignoring false return is not a bug [OK]

Common Mistakes:

• Assuming pop crashes on empty stack
• Thinking push forgets to update head
• Believing next pointer needs explicit nil init

5. You need to implement a stack in Go that can handle an unknown number of elements efficiently and minimize memory waste. Which implementation is best and why? Options: A) Array stack with large fixed size B) Linked list stack C) Array stack with dynamic resizing D) Slice-based stack without capacity checks

hard

A. Array stack with large fixed size

B. Linked list stack

C. Slice-based stack without capacity checks

D. Array stack with dynamic resizing

Solution

1. Step 1: Consider unknown size and memory use

   Large fixed arrays waste memory; linked lists have overhead per node.

2. Step 2: Evaluate dynamic resizing arrays

   Dynamic resizing arrays grow as needed, balancing memory and speed efficiently.

3. Step 3: Assess slice without capacity checks

   Slice without checks risks runtime errors or inefficient growth.

4. Final Answer:

   Array stack with dynamic resizing -> Option D

5. Quick Check:

   Dynamic resizing balances size and memory = C [OK]

Hint: Dynamic arrays grow as needed, saving memory and time [OK]

Common Mistakes:

• Choosing fixed size wastes memory
• Ignoring overhead of linked lists
• Using slices without capacity checks causes errors