DSA Stacks

At GoNimbus, we make learning Data Structures and Algorithms (DSA) easy, engaging, and visual. One of the most essential data structures every programmer must understand is the Stack — a simple yet powerful concept used everywhere from browsers to system memory.

---

What is a Stack?

A Stack is a linear data structure that stores elements in a Last In, First Out (LIFO) order.
That means the last item you add is the first one that gets removed — just like a stack of plates or books.

Real-Life Analogy

Imagine a pile of trays in a cafeteria.
When you add a new tray, it goes on top.
When someone takes a tray, they remove it from the top — not from the middle or bottom.

That’s exactly how a stack behaves in programming!

---

Core Concept: LIFO (Last In, First Out)

Let’s understand this visually:

Step 1: Push(10)
Stack: [10]
Top → 10

Step 2: Push(20)
Stack: [10, 20]
Top → 20

Step 3: Push(30)
Stack: [10, 20, 30]
Top → 30

Step 4: Pop()
Removed 30
Stack: [10, 20]
Top → 20

Explanation:
Each new element is “stacked” on top, and when you remove one, it comes off from the top.
This disciplined structure makes stacks predictable and efficient.

---

Stack Operations

Stacks are managed using five basic operations:

1. Push(element): Add an item to the top.
2. Pop(): Remove and return the top item.
3. Peek() / Top(): Return the top element without removing it.
4. isEmpty(): Check if the stack has no elements.
5. isFull(): Check if the stack has reached maximum capacity (used in fixed-size stacks).

---

Visual Diagram of Stack Operations

Below is a simple diagram showing how elements are added and removed from a stack:

Initial Stack:  (Empty)
   ______
  |      |    ← Top (Empty)
  |______|

Push(10)
   ______
  | 10   |    ← Top = 10
  |______|

Push(20)
   ______
  | 20   |    ← Top = 20
  |______|
  | 10   |
  |______|

Push(30)
   ______
  | 30   |    ← Top = 30
  |______|
  | 20   |
  |______|
  | 10   |
  |______|

Pop()
   ______
  | 20   |    ← Top = 20
  |______|
  | 10   |
  |______|

💡 GoNimbus Tip: Think of the top as the “active” zone — the place where all actions happen!

---

Stack Implementation in Go (Golang)

Here’s a simple example of implementing a stack using Go slices:

package main

import "fmt"

type Stack []int

// Push - Add element to stack
func (s *Stack) Push(value int) {
	*s = append(*s, value)
	fmt.Println(value, "pushed to stack")
}

// Pop - Remove top element
func (s *Stack) Pop() int {
	if len(*s) == 0 {
		fmt.Println("Stack Underflow! Stack is empty.")
		return -1
	}
	index := len(*s) - 1
	element := (*s)[index]
	*s = (*s)[:index]
	fmt.Println(element, "popped from stack")
	return element
}

// Peek - View top element
func (s *Stack) Peek() int {
	if len(*s) == 0 {
		fmt.Println("Stack is empty.")
		return -1
	}
	return (*s)[len(*s)-1]
}

func main() {
	var s Stack
	s.Push(10)
	s.Push(20)
	s.Push(30)
	fmt.Println("Top Element:", s.Peek())
	s.Pop()
	fmt.Println("Stack after Pop:", s)
}

Output:

10 pushed to stack
20 pushed to stack
30 pushed to stack
Top Element: 30
30 popped from stack
Stack after Pop: [10 20]

---

Applications of Stack in the Real World

Stacks are widely used in both system-level programming and application logic:

• 🧩 Function Calls / Recursion:
  Every time you call a function, it’s added to a call stack. Once it completes, it’s popped off.
• 📝 Undo/Redo in Text Editors:
  Each action (typing, deleting) is stored in stacks — one for undo and one for redo.
• 🌐 Browser Navigation:
  When you visit a new page, it’s pushed onto a stack. Pressing ‘Back’ pops the last visited page.
• 🔢 Expression Evaluation:
  Used in compilers to evaluate postfix/prefix expressions and check parentheses balancing.
• 🔍 DFS (Depth First Search):
  Graph traversal algorithms rely on stacks to keep track of visited nodes.

---

Advantages of Stacks

✅ Easy to implement
✅ Efficient for temporary storage
✅ Memory management made simple
✅ Ideal for recursion and backtracking problems

---

Limitations of Stacks

⚠️ Can only access the top element directly
⚠️ Overflow or underflow in fixed-size stacks
⚠️ Limited flexibility in data access

---

Visual Summary

PUSH → Adds element to top
POP  → Removes top element
PEEK → Views top element
EMPTY → Checks if stack is empty

Flow Representation:

          +--------+
          |  Push   |  → Add element to top
          +--------+
               ↓
        +---------------+
        | Stack Storage |
        +---------------+
               ↑
          +--------+
          |  Pop    |  → Remove element from top
          +--------+

---

GoNimbus Insight

At GoNimbus, we don’t just teach syntax — we help you visualize data flow.
Stacks are more than lines of code; they represent structured thinking — disciplined, orderly, and efficient.

Once you truly understand stacks, you’ll see them everywhere — in recursion, undo actions, browser tabs, and even in memory management systems.

---

Practice Corner

Want to test your stack knowledge?
Try solving these at GoNimbus Labs:

• Implement a stack using a linked list.
• Reverse a string using a stack.
• Check for balanced parentheses in an expression.
• Convert an infix expression to postfix using stacks.

Learning is best done by doing — and at GoNimbus, you build to learn.

---