Stack Implementation Using Array in DSA Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a stack in data structures?

A stack is a collection where elements are added and removed in a last-in, first-out (LIFO) order, like a stack of plates.

beginner

What does the 'push' operation do in a stack?

The 'push' operation adds an element to the top of the stack.

beginner

What does the 'pop' operation do in a stack?

The 'pop' operation removes and returns the top element from the stack.

intermediate

How is a stack implemented using an array?

A stack using an array stores elements in a fixed-size list. A variable tracks the top index. Push adds at top+1, pop removes from top, and top index updates accordingly.

intermediate

What happens when you try to push an element into a full stack implemented with an array?

It causes a stack overflow error because the array has no space left to add new elements.

Which operation removes the top element from a stack?

A peek

B push

C pop

D enqueue

The 'pop' operation removes the top element from the stack.

In a stack implemented using an array, what does the 'top' variable represent?

A The total size of the array

B The number of empty spaces

C The bottom element of the stack

D The index of the last added element

The 'top' variable holds the index of the last added element in the stack.

What is the order in which elements are removed from a stack?

A Last In, First Out (LIFO)

B First In, First Out (FIFO)

C Random order

D Sorted order

Stacks follow Last In, First Out (LIFO) order.

What error occurs when pushing to a full stack implemented with an array?

A Stack overflow

B Stack underflow

C Null pointer exception

D Index out of range

Pushing to a full stack causes a stack overflow error.

Which operation lets you see the top element without removing it?

A pop

B peek

C push

D insert

The 'peek' operation returns the top element without removing it.

Explain how to implement a stack using an array and how push and pop operations work.

Think about how you add and remove plates from a stack.

What are the possible errors when using a stack implemented with an array and how do they occur?

Consider what happens if you add too many or remove too many elements.

Practice

1. What is the main purpose of using an array to implement a stack?

easy

A. To sort elements automatically

B. To store elements in a first-in, first-out (FIFO) order

C. To store elements in a last-in, first-out (LIFO) order

D. To allow random access to elements

Solution

1. Step 1: Understand stack behavior

   A stack stores elements so the last added is the first removed, called LIFO.

2. Step 2: Role of array in stack

   An array holds elements in order, supporting push/pop at one end to maintain LIFO.

3. Final Answer:

   To store elements in a last-in, first-out (LIFO) order -> Option C

4. Quick Check:

   Stack = LIFO [OK]

Hint: Stack means last-in, first-out order [OK]

Common Mistakes:

• Confusing stack with queue (FIFO)
• Thinking array sorts elements automatically
• Assuming random access is main stack feature

2. Which of the following is the correct way to declare a stack using an array in Go?

easy

A. stack := []int{}

B. stack := array int

C. var stack [10]int

D. var stack int[]

Solution

1. Step 1: Understand Go slice declaration

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

2. Step 2: Check options for correct syntax

   stack := []int{} uses correct slice literal syntax to create an empty int slice.

3. Final Answer:

   stack := []int{} -> Option A

4. Quick Check:

   Go slice syntax = []type{} [OK]

Hint: Use slice literal []int{} to declare empty stack [OK]

Common Mistakes:

• Using array keyword incorrectly
• Wrong order of type and brackets
• Declaring fixed size array instead of slice

3. What will be the output of the following Go code snippet implementing a stack push and pop?

package main
import "fmt"
func main() {
  stack := []int{}
  stack = append(stack, 10)
  stack = append(stack, 20)
  top := stack[len(stack)-1]
  stack = stack[:len(stack)-1]
  fmt.Println(top)
  fmt.Println(stack)
}

medium

A. 10
[]

B. 20
[10]

C. 20
[10 20]

D. 10
[20]

Solution

1. Step 1: Trace push operations

   stack starts empty, append 10 -> [10], append 20 -> [10, 20]

2. Step 2: Trace pop operation

   top = last element = 20, then remove last element -> stack becomes [10]

3. Final Answer:

   20 [10] -> Option B

4. Quick Check:

   Pop returns 20, stack left with 10 [OK]

Hint: Pop returns last pushed element, stack shrinks [OK]

Common Mistakes:

• Printing stack before pop
• Confusing first element with last
• Not slicing stack correctly after pop

4. Identify the error in this Go code snippet for stack push operation:

package main
func main() {
  var stack []int
  stack[len(stack)] = 5
}

medium

A. Index out of range error

B. Syntax error: missing import

C. No error, code runs fine

D. Type mismatch error

Solution

1. Step 1: Understand slice indexing

   Accessing stack[len(stack)] tries to assign beyond current slice length, causing error.

2. Step 2: Correct push uses append

   To add element, use append(stack, 5) instead of direct index assignment.

3. Final Answer:

   Index out of range error -> Option A

4. Quick Check:

   Assigning at len(slice) causes index error [OK]

Hint: Use append to add elements, not direct index [OK]

Common Mistakes:

• Trying to assign at slice length index
• Forgetting to import fmt (not needed here)
• Assuming slice auto-expands on index assignment

5. Given a stack implemented using an array in Go, how would you modify the pop operation to safely handle popping from an empty stack without causing a runtime error?

hard

A. Replace the stack with a map to avoid empty pop errors

B. Always pop without checking; Go handles empty slices gracefully

C. Use a for loop to pop all elements at once

D. Check if stack length is zero before popping and return an error or zero value

Solution

1. Step 1: Understand pop risk on empty stack

   Popping from empty slice causes index out of range runtime error.

2. Step 2: Add length check before pop

   Check if len(stack) == 0; if yes, return error or zero value to avoid crash.

3. Final Answer:

   Check if stack length is zero before popping and return an error or zero value -> Option D

4. Quick Check:

   Empty stack pop needs length check [OK]

Hint: Always check stack length before pop to avoid errors [OK]

Common Mistakes:

• Ignoring empty stack check causing runtime panic
• Using map instead of array unnecessarily
• Trying to pop all elements in a loop without condition