Data Structures and Algorithms

(DSAs)

Stack and Queue Data Structures

Lecture 3
Outline
 Stack
 Stack Overview
 Stack Representation
 Stack Operations
 peek(), isfull(), isempty

 Push

 Pop

 Queue
 Queue Overview
 Queue Representation
 Queue Basic Operations
 Peek(), isfull(), isempty()

 Enqueue

 Dequeue

 Priority Queue
Stack
 Stack Overview
Stacks are, on an abstract level, equivalent to
linked lists. They are the ideal data structure to
model a First-In-Last-Out (FILO) or Last-In-First-
Out (LIFO), strategy in search.
A stack is an Abstract Data Type (ADT),
commonly used in most programming languages.
It is named stack as it behaves like a real-world
stack, for example – a deck of cards or a pile of
plates, etc.
Stack Overview
A real-world stack allows operations at one end
only. For example, we can place or remove a card
or plate from the top of the stack only.
Likewise, Stack ADT allows all data
operations at one end only. At any given time, we
can only access the top element of a stack.
This feature makes it LIFO data structure. LIFO
stands for Last-in-first-out.
Here, the element which is placed (inserted or
added) last, is accessed first. In stack terminology,
insertion operation is called PUSH operation and
removal operation is called POP operation.
Stack Representation
The following diagram depicts a stack and its
operations;
Stack Representation
A stack can be implemented by means of
Array, Structure, Pointer, and Linked List.
Stack can either be a fixed size one or it may
have a sense of dynamic resizing.

As far as this lecture is concerned, we are

going to implement stack using arrays, which
makes it a fixed size stack implementation
Stack Graphical Representation
Their relation to linked lists means that their
graphical representation can be the same, but
one has to be careful about the order of the
items.
For instance, the stack created by inserting
the numbers [3; 1; 4; 2; 5] in that order would
be represented as:
Stack Operations
Stack operations may involve initializing the
stack, using it and then de-initializing it.
Apart from these basic stuffs, a stack is used
for the following two primary operations;
push() − Pushing (storing) an element on
the stack.
pop() − Removing (accessing) an element
from the stack.

When data is PUSHed onto stack.

Stack Operations
To use a stack efficiently, we need to check the
status of stack as well. For the same purpose, the
following functionality is added to stacks;
 peek() − get the top data element of the stack,
without removing it.
 isfull() − check if stack is full.
 isempty() − check if stack is empty.
At all times, we maintain a pointer to the last
PUSHed data on the stack. As this pointer always
represents the top of the stack, hence named top.
The top pointer provides top value of the stack
without actually removing it.
peek() procedural function
Algorithm;
Isfull() procedural function
Algorithm;
Isempty() procedural function
Algorithm;
Push Operation
The process of putting a new data element onto
stack is known as a Push Operation. Push
operation involves a series of steps;
Step 1 − Checks if the stack is full.
Step 2 − If the stack is full, produces an error
and exit.
Step 3 − If the stack is not full, increments
top to point next empty space.
Step 4 − Adds data element to the stack
location, where top is pointing.
Step 5 − Returns success.
Push Operation
If the linked list is used to implement the
stack, then in step 3, we need to allocate
space dynamically.
Push Operation Algorithm
 Pop Operation
 Accessing the content while removing it from the stack, is
known as a Pop Operation. In an array implementation of pop()
operation, the data element is not actually removed, instead
top is decremented to a lower position in the stack to point to
the next value.
 But in linked-list implementation, pop() actually removes data
element and deallocates memory space.
 A Pop operation may involve the following steps;
 Step 1 − Checks if the stack is empty.
 Step 2 − If the stack is empty, produces an error and exit.
 Step 3 − If the stack is not empty, accesses the data element
at which top is
 pointing.
 Step 4 − Decreases the value of top by 1.
 Step 5 − Returns success.
Pop Operation
Pop Operation Algorithm
QUEUE
Queue Overview
A Queue is an abstract data structure,
somewhat similar to Stacks. Unlike stacks, a
queue is open at both its ends.
One end is always used to insert data
(enqueue) and the other is used to remove
data (dequeue).
Queue follows First-In-First-Out methodology,
i.e., the data item stored first will be accessed
first.

A queue also a data structure used to model a

First-In-First-Out (FIFO) strategy.
Queue example
A real-world example of queue can be a
single-lane one-way road, where the vehicle
enters first, exits first.
More real-world examples can be seen as
queues at the ticket windows and bus-stops.
Queue Representation
As we now understand that in queue, we
access both ends for different reasons.
The following diagram given below tries to
explain queue representation as data
structure
Queue Representation
As in stacks, a queue can also be
implemented using Arrays, Linked-lists,
Pointers and Structures.

For the sake of simplicity, and as far as this

lecture is concerned, we shall implement
queues using one-dimensional array.
Queue Graphical Representation
A queue can be graphically represented in a
similar way to a list or stack, but with an
additional two-cell in which the first element
points to the front of the list of all the
elements in the queue, and the second
element points to the last element of the list.
For instance, if we insert the elements [3; 1;
4; 2] into an initially empty queue, we get:
Queue Graphical Representation
The graphical arrangement on the previous
slide means that taking the first element of
the queue, or adding an element to the back
of the queue, can both be done efficiently.

In particular, they can both be done with

constant effort, i.e. independently of the
queue length.
Queue Basic Operations
Queue operations may involve initializing or
defining the queue, utilizing it, and then
completely erasing it from the memory.

Here we shall try to understand the basic

operations associated with queues;

 enqueue() − add (store) an item to the

queue.
dequeue() − remove (access) an item from
the queue.
Queue Basic Operations
Few more functions are required to make the
mentioned queue operation efficient.

These are include;

 peek() − Gets the element at the front of the queue
without removing it.
 isfull() − Checks if the queue is full.
 isempty() − Checks if the queue is empty.

In queue, we always dequeue (or access) data,

pointed by front pointer and while enqueing (or
storing) data in the queue we take help of rear
pointer.
peek() function
This function helps to see the data at the
front of the queue.
Algorithm of peek() function;
isfull() function
As we are using single dimension array to
implement queue, we just check for the rear
pointer to reach at MAXSIZE to determine
that the queue is full. In case we maintain the
queue in a circular linked-list, the algorithm
will differ.
Algorithm of isfull() function;
isempty() function
If the value of front is less than MIN or 0, it
tells that the queue is not yet initialized,
hence empty.
Algorithm of isempty() function;
Enqueue Operation
Queues maintain two data pointers, front and rear.
Therefore, its operations are comparatively difficult
to implement than that of stacks.
The following steps should be taken to enqueue
(insert) data into a queue;
Step 1 − Check if the queue is full.
Step 2 − If the queue is full, produce overflow error
and exit.
Step 3 − If the queue is not full, increment rear
pointer to point the next empty space.
Step 4 − Add data element to the queue location,
where the rear is pointing.
Step 5 − Return success.
Enqueue Operation
Sometimes, we also check to see if a queue is
initialized or not, to handle any unforeseen
situations.
Enqueue Algorithm
Dequeue Operation
Accessing data from the queue is a process of two
tasks − access the data where front is pointing and
remove the data after access.
The following steps are taken to perform dequeue
operation;
Step 1 − Check if the queue is empty.
Step 2 − If the queue is empty, produce underflow
error and exit.
Step 3 − If the queue is not empty, access the data
where front is pointing.
Step 4 − Increment front pointer to point to the
next available data element.
Step 5 − Return success.
Dequeue Operation
Dequeue Algorithm
Priority Queue
While most queues in every-day life operate on a first
come, first served basis, it is sometimes important to
be able to assign a priority to the items in the queue,
and always serve the item with the highest priority
next.
An example of this would be in a hospital casualty
department, where life-threatening injuries need to
be treated first.
The structure of a complete binary tree in array form
is particularly useful for representing such priority
queues.
It turns out that these queues can be implemented
efficiently by a particular type of complete binary
tree known as a binary heap tree.
Priority Queue
The idea is that the node labels, which were the
search keys when talking about binary search
trees, are now numbers representing the priority
of each item in question (with higher numbers
meaning a higher priority in our examples).
With heap trees, it is possible to insert and delete
element efficiently without having to keep the
whole tree sorted like a binary search tree.
This is because we only ever want to remove one
element at a time, namely the one with the highest
priority present, and the idea is that the highest
priority item will always be found at the root of the
tree.
Questions