Understanding Stacks and Queues: Fundamental Data Structures in Computer Science

By Juan Carlos Angulo, Senior Tech SEO & Software Engineer

In programming and computer science, understanding data structures is fundamental. Two of the most commonly used linear data structures are Stacks and Queues. Despite their apparent simplicity, they serve as foundational building blocks not only for algorithms but also for complex data manipulations. This article aims to provide an in-depth look at these structures, their properties, differences, applications, and implementations.

What Are Stacks?

Definition and Properties

A Stack is a collection of elements that follows a particular order for operations. The principle that defines a Stack is referred to as LIFO (Last In, First Out). This means that the last element added to the stack will be the first one to be removed.

For example, think of a stack of plates. You can only take the top plate off the stack (LIFO), and you can only add a new plate on top.

Common Operations

The primary operations associated with stacks are:

• Push: Adds an element to the top of the stack.
• Pop: Removes the top element from the stack.
• Peek: Returns the top element without removing it.
• IsEmpty: Checks if the stack is empty.

Use Cases

Stacks are utilized in a variety of applications including:

• Function call management: The execution context and local variables are often managed using stacks.
• Undo mechanisms: In applications like text editors, stacks are used to keep track of changes so that they can be undone.
• Expression evaluation: Stacks facilitate the conversion from infix to postfix expressions, as seen in compilers.

Implementing a Stack

Stack Implementation in Python

Let's explore a basic implementation of a stack in Python using a list:

1class Stack:
2    def __init__(self):
3        self.items = []
4    
5    def push(self, item):
6        self.items.append(item)
7    
8    def pop(self):
9        if not self.is_empty():
10            return self.items.pop()
11        raise IndexError("pop from empty stack")
12    
13    def peek(self):
14        if not self.is_empty():
15            return self.items[-1]
16        raise IndexError("peek from empty stack")
17    
18    def is_empty(self):
19        return len(self.items) == 0
20
21# Example usage
22stack = Stack()
23stack.push(1)
24stack.push(2)
25print(stack.peek())  # Output: 2
26stack.pop()
27print(stack.peek())  # Output: 1
Copy

What Are Queues?

Definition and Properties

A Queue is another collection of elements, but it differs in its operational order: it follows the FIFO (First In, First Out) principle. The first element added to the queue will be the first one to be removed.

Imagine a line of people waiting to enter a theater. The first person in line is the first to enter; hence, it operates on a FIFO basis.

Common Operations

Queues support a set of primary operations:

• Enqueue: Adds an element at the back of the queue.
• Dequeue: Removes the front element from the queue.
• Front: Returns the front element without removing it.
• IsEmpty: Checks if the queue is empty.

Use Cases

Queues are employed in many scenarios, such as:

• Scheduling processes: In operating systems, queues manage processes waiting for execution or resources.
• Breadth-First Search (BFS): In graph algorithms, queues help traverse nodes level by level.
• Print job management: In printers, queues manage multiple print jobs effectively.

Implementing a Queue

Queue Implementation in Python

Here is a straightforward implementation of a queue in Python using a list:

1class Queue:
2    def __init__(self):
3        self.items = []
4    
5    def enqueue(self, item):
6        self.items.append(item)
7    
8    def dequeue(self):
9        if not self.is_empty():
10            return self.items.pop(0)
11        raise IndexError("dequeue from empty queue")
12    
13    def front(self):
14        if not self.is_empty():
15            return self.items[0]
16        raise IndexError("front from empty queue")
17    
18    def is_empty(self):
19        return len(self.items) == 0
20
21# Example usage
22queue = Queue()
23queue.enqueue(1)
24queue.enqueue(2)
25print(queue.front())  # Output: 1
26queue.dequeue()
27print(queue.front())  # Output: 2
Copy

Key Differences Between Stacks and Queues

While both stacks and queues are linear data structures, their core operational logic and intended applications significantly differ:

See Also

• Data Structures: An Overview and Their Applications
• Algorithms and Data Structures 2026: The Engineer's Foundation
• Recursion Algorithms