Stack Implementation Using Array in DSA Go - Build from Scratch

Stack Implementation Using Array

📖 Scenario: Imagine you are building a simple undo feature for a text editor. You want to keep track of the last few actions using a stack. A stack works like a stack of plates: you add plates on top and remove the top plate first.

🎯 Goal: You will create a stack using an array in Go. You will add items (push), remove items (pop), and see the current stack.

📋 What You'll Learn

Create a stack as a slice of strings called stack with initial elements

Create a variable maxSize to limit the stack size

Write a function push to add an element if stack is not full

Write a function pop to remove the top element if stack is not empty

Print the stack after operations

💡 Why This Matters

🌍 Real World

Stacks are used in undo features, expression evaluation, and backtracking algorithms.

💼 Career

Understanding stack implementation helps in software development, debugging, and working with system internals.

1

Create the initial stack

Create a slice of strings called stack with these exact elements: "open file", "edit text", "save file"

DSA Go

# Create a slice called stack with the elements "open file", "edit text", "save file"
# Your code here

Hint

Use stack := []string{...} to create the slice with the exact elements.

2

Add a maximum size for the stack

Create an integer variable called maxSize and set it to 5 to limit the stack size

DSA Go

package main

import "fmt"

func main() {
    stack := []string{"open file", "edit text", "save file"}
    
    // Create maxSize variable and set to 5
    // Your code here
}

Hint

Use maxSize := 5 to create the limit variable.

3

Write push and pop functions

Write a function push that takes a slice of strings called stack, a string called action, and an integer maxSize. It returns the updated stack after adding action if the stack length is less than maxSize. Also write a function pop that takes a slice of strings called stack and returns the updated stack after removing the last element if the stack is not empty. Use these functions inside main to push "undo edit" and then pop once.

DSA Go

package main

import "fmt"

func push(stack []string, action string, maxSize int) []string {
    // Your code here
}

func pop(stack []string) []string {
    // Your code here
}

func main() {
    stack := []string{"open file", "edit text", "save file"}
    maxSize := 5

    // Use push to add "undo edit"
    // Use pop to remove the last element
    // Your code here
}

Hint

Use append to add and slice to remove the last element. Check length before adding or removing.

4

Print the final stack

Print the stack slice inside main to show the current stack after push and pop operations

DSA Go

package main

import "fmt"

func push(stack []string, action string, maxSize int) []string {
    if len(stack)  0 {
        stack = stack[:len(stack)-1]
    }
    return stack
}

func main() {
    stack := []string{"open file", "edit text", "save file"}
    maxSize := 5

    stack = push(stack, "undo edit", maxSize)
    stack = pop(stack)

    // Print the stack
    // Your code here
}

Hint

Use fmt.Println(stack) to print the slice.

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