📦 Introduction to Stack, LIFO Principle, Terminologies & Real-World Applications
Welcome to the Stack in Java series!
So far, we have learned several important data structures, including:
- ✅ Arrays
- ✅ Singly Linked Lists
- ✅ Doubly Linked Lists
Now it’s time to learn one of the most important and widely used linear data structures in Computer Science—the Stack.
Stacks are used everywhere!
From your web browser and text editor to the Java Virtual Machine (JVM), recursion, expression evaluation, and even the Undo feature in applications—all of these rely on stacks.
In this tutorial, you’ll learn the complete theory behind stacks before implementing them using Arrays and Linked Lists in the next parts.
📚 Table of Contents
- What is a Stack?
- Why Do We Need a Stack?
- History of Stack
- LIFO Principle
- Real-Life Examples
- Basic Terminologies
- Stack Operations
- Stack Representation
- Applications of Stack
- Advantages
- Disadvantages
- Time Complexity
- Frequently Asked Questions
- Conclusion
📖 What is a Stack?
A Stack is a linear data structure that follows the LIFO (Last In, First Out) principle.
This means:
The last element inserted into the stack is the first element removed.
Think of it as a pile of books.
When you place books one on top of another, the last book you place is the first one you can remove.
Example
Top
↓
+------+
| 50 |
+------+
| 40 |
+------+
| 30 |
+------+
| 20 |
+------+
| 10 |
+------+
Bottom
If you remove one element,
the value removed will be
50
🤔 Why Do We Need a Stack?
Imagine you’re using Microsoft Word.
You type
Hello
Then
Hello World
You press Undo.
The latest action disappears first.
Why?
Because the application remembers the most recent operation first.
This is exactly how a Stack works.
Similarly,
when you visit websites
Google
↓
YouTube
↓
Wikipedia
Pressing the Back button takes you to the previous page in reverse order.
Again,
a Stack is being used.
📜 A Brief History of Stack
The stack concept became popular during the early development of programming languages and compilers.
It was introduced to efficiently manage:
- Function calls
- Local variables
- Recursion
- Program execution
Today, almost every programming language internally uses a Call Stack.
📦 Understanding the LIFO Principle
LIFO stands for
Last In, First Out
Let’s understand it using an example.
Insert
10
20
30
40
50
The stack becomes
Top
↓
50
40
30
20
10
Now remove elements.
The removal order will be
50
↓
40
↓
30
↓
20
↓
10
Notice that
the last inserted element (50) was removed first.
🌍 Real-Life Examples of Stack
🍽 Stack of Plates
One of the best examples.
Imagine plates kept in a restaurant.
Top
🍽
🍽
🍽
🍽
Bottom
The last plate placed is always removed first.
📚 Stack of Books
Book 5
Book 4
Book 3
Book 2
Book 1
To remove Book 1,
you must first remove all books above it.
🚗 Parking Garage
Cars parked in a single narrow lane behave like a stack.
The last car parked exits first.
🌐 Browser History
Visit pages
Google
↓
OpenAI
↓
GitHub
↓
YouTube
Back button removes
YouTube
↓
GitHub
↓
OpenAI
↓
Google
✏ Undo Operation
Typing
A
↓
AB
↓
ABC
↓
ABCD
Undo
ABCD
↓
ABC
↓
AB
↓
A
📖 Basic Terminologies
Before implementing a stack, let’s understand some important terms.
📍 Top
The Top points to the last inserted element.
Example
Top
↓
50
40
30
20
Current Top
50
📍 Bottom
The bottom stores the oldest element.
50
40
30
20
10
Bottom
10
📍 Push
Push means
Insert an element into the stack.
Example
Current
30
20
10
Push
40
Result
40
30
20
10
📍 Pop
Pop means
Remove the top element.
Current
40
30
20
10
Pop
40
Result
30
20
10
📍 Peek (Top)
Peek means
View the top element without removing it.
Current
50
40
30
Peek
50
Stack remains unchanged.
📍 Overflow
Overflow occurs when we try to insert an element into a full stack.
Example
Suppose the stack size is
5
Already contains
10
20
30
40
50
Push
60
Result
Stack Overflow
📍 Underflow
Underflow occurs when we try to remove an element from an empty stack.
Current
Empty Stack
Pop
Result
Stack Underflow
🔧 Basic Stack Operations
Every Stack supports five important operations.
➕ Push
Insert an element.
➖ Pop
Remove the top element.
👀 Peek
Display the top element.
❓ isEmpty()
Checks whether the stack is empty.
Returns
True
or
False
📋 Display
Print all elements.
🎨 Stack Representation
Suppose we push
10
20
30
40
The stack becomes
Top
↓
+------+
| 40 |
+------+
| 30 |
+------+
| 20 |
+------+
| 10 |
+------+
Now perform
Pop()
Result
Top
↓
+------+
| 30 |
+------+
| 20 |
+------+
| 10 |
+------+
🌍 Applications of Stack
Stacks are used in many applications.
💻 Function Calls
Every function call is stored in a Call Stack.
🔁 Recursion
Recursive functions use stacks internally.
🌐 Browser Back Button
Stores visited webpages.
✏ Undo & Redo
Editors use stacks to undo and redo operations.
🧮 Expression Evaluation
Stacks evaluate
- Postfix
- Prefix
expressions.
🔤 Parentheses Matching
Compilers use stacks to check
()
{}
[]
🌳 Depth First Search (DFS)
DFS uses stacks for graph traversal.
🎮 Backtracking
Maze solving
Sudoku
Chess engines
AI algorithms
💾 Java Virtual Machine
Every Java program uses a JVM Stack to manage:
- Method Calls
- Parameters
- Local Variables
- Return Addresses
🌟 Advantages of Stack
✅ Simple implementation.
✅ Fast insertion.
✅ Fast deletion.
✅ Supports recursion.
✅ Efficient memory management.
✅ Useful in many real-world applications.
❌ Disadvantages
❌ Random access is not possible.
❌ Only the top element is accessible.
❌ Overflow may occur in fixed-size stacks.
❌ Searching is inefficient.
📊 Time Complexity
| Operation | Time Complexity |
|---|---|
| Push | O(1) |
| Pop | O(1) |
| Peek | O(1) |
| isEmpty | O(1) |
| Display | O(n) |
| Search | O(n) |
⚖️ Stack vs Queue
| Feature | Stack | Queue |
|---|---|---|
| Principle | LIFO | FIFO |
| Insertion | Top | Rear |
| Deletion | Top | Front |
| Example | Plate Stack | Ticket Queue |
🎯 Common Interview Questions
Q1. What is a Stack?
A Stack is a linear data structure that follows the LIFO (Last In, First Out) principle.
Q2. What is LIFO?
The last element inserted is the first element removed.
Q3. What are the basic Stack operations?
- Push
- Pop
- Peek
- isEmpty
- Display
Q4. What is Overflow?
Overflow occurs when inserting into a full stack.
Q5. What is Underflow?
Underflow occurs when removing from an empty stack.
Q6. What is the time complexity of Push?
O(1)
Q7. Which real-world applications use stacks?
- Browser History
- Undo/Redo
- Function Calls
- Recursion
- Expression Evaluation
- Parentheses Matching
- DFS
Q8. Can we access the middle element directly?
No.
Stacks allow access only to the top element.
🎯 Key Takeaways
- 📦 Stack follows the LIFO principle.
- ➕ Push inserts an element.
- ➖ Pop removes the top element.
- 👀 Peek displays the top element without removing it.
- ⚠ Overflow occurs when a full stack receives another element.
- ⚠ Underflow occurs when removing from an empty stack.
- 🚀 Push, Pop, and Peek all take O(1) time.
- 🌍 Stacks are widely used in compilers, browsers, editors, recursion, and operating systems.
🎉 Conclusion
A Stack is one of the simplest yet most powerful data structures in Computer Science. Its LIFO behavior makes it ideal for solving problems where the most recently added item must be processed first. Whether you’re implementing browser history, undo functionality, recursive algorithms, or expression evaluation, stacks play a fundamental role.
Understanding the concepts covered in this part will make it much easier to implement stacks efficiently using different data structures.
👉 In Part 2, we’ll learn how to implement a Stack using Arrays, including:
- 📦 Creating a Stack
- ➕ Push Operation
- ➖ Pop Operation
- 👀 Peek Operation
- ❓ isEmpty()
- ❓ isFull()
- 📋 Display Operation
- 💻 Complete Java Program
- 🔍 Dry Runs
- 📈 Time Complexity Analysis
