Stack & Queue Data Structures

In this tutorial, we will discuss together the definition of stack and queue and discover their different uses.

---

Stack

In computer science, a stack is an abstract data type that serves as a collection of elements, with two main principal operations:

• Push: which adds an element to the collection

• Pop: which removes the most recently added element that was not yet removed

It is a data structure based on the LIFO "Last In, First Out" principle, which means that the last elements added to the stack will be the first to be retrieved.

You can think of the stack data structure as the pile of plates on top of another.

Here, you can:

• Put a new plate on top

• Remove the top plate

And, if you want the plate at the bottom, you must first remove all the plates on top. This is exactly how the stack data structure works.

Implementation

In programming terms, putting an item on top of the stack is called push and removing an item is called pop.

In the above image, although item 2 was kept last, it was removed first. This is exactly how the LIFO (Last In First Out) Principle works.

We can implement a stack in any programming language like Python. There are some basic operations that allow us to perform different actions on a stack.

• Push: Add an element to the top of a stack

• Pop: Remove an element from the top of a stack

• IsEmpty: Check if the stack is empty

• IsFull: Check if the stack is full

• Peek: Get the value of the top element without removing it

# Creating a stack
def create_stack():
    stack = []
    return stack
    
# Checking if stack is empty
def check_empty(stack):
    return len(stack) == 0
    
# Adding items into the stack
def push(stack, item):
    stack.append(item)
    print("pushed item: " + item)

# Removing an element from the stack
def pop(stack):
    if (check_empty(stack)):
        return "stack is empty"
    return stack.pop()

stack = create_stack()
push(stack, "1")
push(stack, "2")
push(stack, "3")
push(stack, "4")
print("popped item: " + pop(stack))
print("stack after popping an element: " + str(stack))

pushed item: 1
pushed item: 2
pushed item: 3
pushed item: 4
popped item: 4
stack after popping an element: ['1', '2', '3']

Applications of Stack Data Structure

Stacks have various applications:

• In browsers: he back button in a browser saves all the URLs you have visited previously in a stack. Each time you visit a new page, it is added on top of the stack. When you press the back button, the current URL is removed from the stack, and the previous URL is accessed.

• The evaluation of mathematical expressions in postfixed (or reverse Polish) notation uses a stack.

• The Undo function of a word processor stores changes made to text in a stack

---

Queue

In computer science, a queue is a collection of entities that are maintained in a sequence and can be modified by the addition of entities at one end of the sequence and the removal of entities from the other end of the sequence. By convention, the end of the sequence at which elements are added is called the back, tail, or rear of the queue, and the end at which elements are removed is called the head or front of the queue, analogously to the words used when people line up to wait for goods or services.

In the above image, since the first person was kept in the queue before the second one, it is the first to be removed from the queue as well. It follows the FIFO rule.

Implementation

In programming terms, putting items in the queue is called enqueue, and removing items from the queue is called dequeue.

We can implement the queue using python following basics operations.

• Enqueue: Add an element to the end of the queue

• Dequeue: Remove an element from the front of the queue

• IsEmpty: Check if the queue is empty

• IsFull: Check if the queue is full

• Peek: Get the value of the front of the queue without removing it

class Queue:

    def __init__(self):
        self.queue = []
        
    # Add an element
    def enqueue(self, item):
        self.queue.append(item)
        
    # Remove an element
    def dequeue(self):
        if len(self.queue) < 1:
            return None
        return self.queue.pop(0)
        
    # Display  the queue
    def display(self):
        print(self.queue)
    
    def size(self):
        return len(self.queue)
        
q = Queue()
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
q.enqueue(4)
q.enqueue(5)

q.display()

q.dequeue()

print("After removing an element")
q.display()

[1, 2, 3, 4, 5]
After removing an element
[2, 3, 4, 5]

Applications of Queue

• CPU scheduling, Disk Scheduling

• When data is transferred asynchronously between two processes.The queue is used for synchronization. For example: IO Buffers, pipes, file IO, etc

• Call Center phone systems use Queues to hold people calling them in order.

Link to GitHub repo.

Reference:

programiz.com