Why Stack Exists and What Problems It Solves in DSA Go - Quick Recap

Recall & Review

beginner

What is a stack in simple terms?

A stack is like a pile of plates where you can only add or remove the top plate. It follows the Last In, First Out (LIFO) rule.

beginner

Why do we need a stack in programming?

Stacks help manage tasks that need to be done in reverse order, like undo actions, function calls, or checking matching brackets.

intermediate

What problem does a stack solve when dealing with function calls?

It keeps track of which function called which, so when a function finishes, the program knows where to return next.

intermediate

How does a stack help in undo operations?

Each action is saved on the stack. When undo is pressed, the last action is removed and reversed, following LIFO order.

beginner

What is a real-life example of a stack?

A stack of books where you can only take the top book off or add a new book on top.

What order does a stack follow?

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), meaning the last item added is the first to be removed.

Which of these is NOT a common use of a stack?

A Sorting numbers

B Function call tracking

C Undo operations

D Checking balanced parentheses

Stacks are not typically used for sorting numbers; other data structures like arrays or heaps are used for sorting.

In a stack, where do you add new items?

A At the bottom

B In the middle

C Anywhere

D At the top

New items are always added at the top of the stack.

What happens when you pop an item from a stack?

A The bottom item is removed

B The top item is removed

C All items are removed

D No item is removed

Popping removes the top item from the stack.

Why is a stack useful for checking matching brackets?

A Because it counts brackets

B Because it sorts brackets

C Because it remembers the last opened bracket to match with the next closing one

D Because it ignores brackets

A stack helps by remembering the last opened bracket so it can be matched with the next closing bracket.

Explain why a stack is important for managing function calls in a program.

Think about how the program remembers where to go back after a function ends.

Describe a real-life situation where a stack is used and how it works.

Imagine a pile of something you can only take from the top.

Practice

1. Why do we use a stack data structure in programming?

easy

A. To sort numbers in ascending order automatically

B. To store data in random order for quick access

C. To keep track of function calls and return in the correct order

D. To store data permanently on disk

Solution

1. Step 1: Understand the role of stack in function calls

   Stacks help keep track of which function called which, so the program can return to the right place after finishing a function.

2. Step 2: Recognize the order of operations in stacks

   Stacks follow Last In First Out (LIFO), which matches how function calls return in reverse order.

3. Final Answer:

   To keep track of function calls and return in the correct order -> Option C

4. Quick Check:

   Stack = function call tracking [OK]

Hint: Stack tracks last function called first returned [OK]

Common Mistakes:

• Thinking stack stores data randomly
• Confusing stack with sorting
• Assuming stack stores data permanently

2. Which of the following is the correct way to push an element onto a stack in Go using a slice?

easy

A. stack = append(stack, element)

B. stack.push(element)

C. stack.add(element)

D. stack.insert(element)

Solution

1. Step 1: Recall how slices work in Go

   In Go, slices can be appended using the built-in append function.

2. Step 2: Identify the correct syntax for adding to stack

   Since stack is a slice, adding an element is done by stack = append(stack, element).

3. Final Answer:

   stack = append(stack, element) -> Option A

4. Quick Check:

   Go slice append = push stack [OK]

Hint: Use append() to add element to slice stack [OK]

Common Mistakes:

• Using non-existent push method on slice
• Using add or insert which are not Go slice methods
• Forgetting to assign back to stack after append

3. What will be the output of the following Go code snippet?

stack := []int{}
stack = append(stack, 10)
stack = append(stack, 20)
stack = append(stack, 30)
last := stack[len(stack)-1]
stack = stack[:len(stack)-1]
fmt.Println(last)

medium

A. 10

B. 30

C. Error

D. 20

Solution

1. Step 1: Trace the stack after each append

   After appending 10, 20, 30, stack = [10, 20, 30].

2. Step 2: Identify the last element and remove it

   last = stack[len(stack)-1] = 30; then stack is sliced to remove last element.

3. Final Answer:

   30 -> Option B

4. Quick Check:

   Last pushed = 30 popped = 30 [OK]

Hint: Last appended element is popped and printed [OK]

Common Mistakes:

• Printing first element instead of last
• Confusing slice indexing
• Expecting error due to slicing

4. Find the error in this Go code that tries to pop an element from a stack represented by a slice:

stack := []int{1, 2, 3}
last := stack[len(stack)]
stack = stack[:len(stack)-1]
fmt.Println(last)

medium

A. Index out of range error when accessing stack[len(stack)]

B. Syntax error in slice operation

C. No error, code works fine

D. Stack slice is empty before pop

Solution

1. Step 1: Check indexing used to get last element

   stack[len(stack)] tries to access index equal to length, which is out of range (indexes go from 0 to len-1).

2. Step 2: Confirm correct index for last element

   The last element is at stack[len(stack)-1], so the code causes runtime error.

3. Final Answer:

   Index out of range error when accessing stack[len(stack)] -> Option A

4. Quick Check:

   Indexing error = Index out of range error when accessing stack[len(stack)] [OK]

Hint: Last element index is length-1, not length [OK]

Common Mistakes:

• Using len(stack) as index instead of len(stack)-1
• Assuming slice indexing starts at 1
• Ignoring runtime errors

5. You want to reverse a string using a stack in Go. Which approach correctly uses a stack to reverse the string "hello"?

hard

A. Sort characters alphabetically to reverse string

B. Append characters directly to a new string without stack

C. Use a queue to store characters and dequeue to reverse

D. Push each character onto a stack, then pop all to build reversed string

Solution

1. Step 1: Understand stack's LIFO property for reversing

   Pushing characters in order and popping reverses their order.

2. Step 2: Identify correct method to reverse string using stack

   Push all chars, then pop to build reversed string matches stack usage.

3. Final Answer:

   Push each character onto a stack, then pop all to build reversed string -> Option D

4. Quick Check:

   Stack LIFO reverses string [OK]

Hint: Stack reverses order by popping last pushed first [OK]

Common Mistakes:

• Using queue which reverses differently
• Appending without stack does not use stack concept
• Sorting changes order, not reverses