• Home /
  • DevOps /
  • Stacks and Queues Explained (LIFO vs FIFO with Real Examples)

Stacks and Queues Explained (LIFO vs FIFO with Real Examples)

Stacks and Queues are linear data structures that control how data is accessed and processed

  • Stack → LIFO (Last In, First Out)
  • Queue → FIFO (First In, First Out)

Stacks are used where the most recent item matters (undo, recursion).

Queues are used where order matters (task scheduling, requests).

If Linked Lists teaches you how data connects, Stacks and Queues teach you how data flows.

A Simple Story Before We Start

You’re using an app.

You open a screen → then another → then another.

Now you press the back button.

What happens?

You go back step by step, in reverse order.

Last opened → first closed.

That’s a Stack.

 

Now imagine booking a ticket.

People stand in a line.

The first person in line gets served first.

That’s a Queue.

 

Two completely different behaviors.

Two completely different data structures.

Both are used everywhere in systems.

What Are Stacks and Queues?

They are abstract data structures that define how elements are added and removed.

Unlike arrays or linked lists, which focus on storage, these focus on order of processing.

Stack Explained (LIFO)

A Stack follows:

👉 Last In, First Out

Think of stacking plates:

  • Last plate placed → first one removed

Stack Operations

  • Push → add element
  • Pop → remove element
  • Peek → view top element

Example Code (Java) 

// Example Code (Java)
Stack<Integer> stack = new Stack<>();

stack.push(10);
stack.push(20);
stack.push(30);

stack.pop(); // removes 30

How Stack Works

Time Complexity

Operation

Complexity

Push

O(1)

Pop

O(1)

Peek

O(1)

Real-World Uses of Stack

1. Undo / Redo Systems

Every action is pushed to stack.

Undo pops the last action.

2. Browser Navigation

Back button works using stack behavior.

3. Function Calls (Call Stack)

Every function call is stored in stack memory.

4. Expression Evaluation

Used in parsing and evaluating expressions.

Queue Explained (FIFO)

A Queue follows:

👉 First In, First Out

Like a line at a ticket counter.

Queue Operations

  • Enqueue → add element
  • Dequeue → remove element
  • Front → view first element

Example Code (Java) 

Queue queue = new LinkedList<>();

queue.add(10);
queue.add(20);
queue.add(30);

queue.remove(); // removes 10

How Queue Works

Elements are processed in the order they arrive.

Time Complexity

Operation

Complexity

Enqueue

O(1)

Dequeue

O(1)

Front

O(1)

Real-World Uses of Queue

1. Task Scheduling

CPU processes tasks in order.

2. API Request Handling

Requests are queued and processed sequentially.

3. Print Queue

Documents are printed in order.

4. Messaging Systems

Messages are processed FIFO.

Stack vs Queue

Feature Stack Queue
Principle LIFO FIFO
Access Top only Front & rear
Use case Undo, recursion Scheduling, processing
Order Reverse Sequential

Visual Comparison

Why These Structures Matter

Stacks and Queues are not just academic concepts.

They are used in:

  • operating systems
  • compilers
  • web browsers
  • distributed systems

They define how systems process data internally.

They are used in:

Common Mistakes Beginners Make

1. Confusing LIFO and FIFO

Stack ≠ Queue

2. Trying to access middle elements

These structures restrict access intentionally.

3. Ignoring use cases

Each is designed for a specific type of problem.

A Simple Rule to Remember

  • If the last action matters → use Stack
  • If order matters → use Queue

Frequently Asked Questions (FAQ)

Yes. Arrays or linked lists both works.

Yes. Using two stacks.

Both have O(1) operations for basic actions.

Yes, extensively.

Final Thoughts

Stacks and Queues introduce a powerful idea:

  • Not all data should be accessed freely.
  • Sometimes, restricting access creates predictable and efficient systems.
  • Stacks help in reversing and backtracking.
  • Queues help in managing order and flow.
  • Together, they form the backbone of many real-world systems.

Ready to master Data Structures and Algorithms with real-world coding examples and system-level understanding?

Join the DSA Program at CodeKerdos and learn Arrays, Linked Lists, Stacks, Queues, Trees, Graphs, and System Design through hands-on Java projects and interview-focused training.

Scroll to Top