Stack and Queue

Linear Data Structure

 What is a Stack?
A stack is a linear data structure in which the insertion of a new
element and removal of an existing element takes place at the same
end represented as the top of the stack.

To implement the stack, it is required to maintain the pointer to the

top of the stack, which is the last element to be inserted because we
can access the elements only on the top of the stack.
 LIFOLast In First Out

This strategy states that the element that is inserted last will come out first.
Basic Operation on Stack
push() to insert an element into the stack
pop() to remove an element from the stack
top() Returns the top element of the stack.
isEmpty() returns true if stack is empty else false.
size() returns the size of stack.
 Push Operation
Adds an item to the stack. If the stack is full, then it is said to be an Overflow
begin
if stack is full
return
endif
else
increment top
stack[top] assign value
end else
end procedure
 Pop Operation
Removes an item from the stack. The items are popped in the reversed order in which they
are pushed. If the stack is empty, then it is said to be an Underflow condition.
begin
if stack is empty
return
endif
else
store value of stack[top]
decrement top
return value
end else
end procedure
Top Operation
Returns the top element of the stack.

begin
return stack[top]
end procedure
isEmpty Operation
Returns true if the stack is empty, else false.

begin
if top < 1
return true
else
return false
end procedure
Size Operation
Returns the size of the stack.

begin
return stack
end procedure
 Types of Stacks
Fixed Size Stack:
As the name suggests, a fixed size stack has a fixed size and cannot grow or
shrink dynamically. If the stack is full and an attempt is made to add an element
to it, an overflow error occurs. If the stack is empty and an attempt is made to
remove an element from it, an underflow error occurs.
Dynamic Size Stack:
A dynamic size stack can grow or shrink dynamically. When the stack is full, it
automatically increases its size to accommodate the new element, and when the
stack is empty, it decreases its size. This type of stack is implemented using a
linked list, as it allows for easy resizing of the stack.
Applications of Stacks
Infix to Postfix /Prefix conversion
Infix – A+B
Postfix – AB+
Prefix- +AB
 Redo-undo features at many places like editors, photoshop.

Forward and backward features in web browsers

Used in many algorithms like Tower of Hanoi, tree traversals, stock span
problems, and histogram problems.
Backtracking is one of the algorithm designing techniques. To get back
from a current state we need to store the previous state for that purpose
we need a stack.
 In Graph Algorithms

In Memory management, any modern computer uses a stack as the

primary management for a running purpose. Each program that is running in
a computer system has its own memory allocations.

Stack also helps in implementing function call in

computers. The last called function is always completed
first.
Stacks are also used to implement the undo/redo operation in text
editor.
 Implementation of Stacks
A stack can be implemented using an array or a linked list.

In an array-based implementation, the push operation is implemented by

incrementing the index of the top element and storing the new element at that
index.
The pop operation is implemented by decrementing the index of the top element
and returning the value stored at that index.
 In a linked list-based implementation, the push operation is
implemented by creating a new node with the new element and setting
the next pointer of the current top node to the new node. The pop
operation is implemented by setting the next pointer of the current top
node to the next node and returning the value of the current top node.
SUMMARY
 In conclusion, a Stack is a linear data structure that operates on the
LIFO principle and can be implemented using an array or a linked list.
The basic operations that can be performed on a stack include push,
pop, and peek.
Stacks are commonly used in computer science for a variety of
applications, including the evaluation of expressions, function calls, and
memory management.

There are two ways to implement a stack –

 Using array
 Using linked list
FIN
 QUEUE?
A queue is a linear data structure that is open at both ends and the
operations are performed in First In First Out (FIFO) order.

We define a queue to be a list in which all additions to the list are

made at one end, and all deletions from the list are made at the other
end. The element which is first pushed into the order, the delete
operation is first performed on that.
 FIFOFirst In First Out

This strategy states that the element that is inserted first will come out first.
Basic Operation on Queue
Enqueue() – Adds (or stores) an element to the end of the queue..
Dequeue() – Removal of elements from the queue.
Peek() or front()- Acquires the data element available at the front node of the
queue without deleting it.
rear() – This operation returns the element at the rear end without removing it.
isFull() – Validates if the queue is full.
isNull() – Checks if the queue is empty.
 Enqueue Operation
Enqueue() operation in Queue adds (or stores) an element to the end of the queue.
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, return overflow error
and exit.
Step 3: If the queue is not full, increment the rear
pointer to point to the next empty space.
Step 4: Add the data element to the queue location,
where the rear is pointing.
Step 5: return success.
Dequeue Operation
Removes (or access) the first element from the queue.
The following steps should be taken to perform dequeue operation:

Step 1: Check if the queue is empty.

Step 2: If the queue is empty, return the underflow
error and exit.
Step 3: If the queue is not empty, access the data
where the front is pointing.
Step 4: Increment the front pointer to point to the
next available data element.
Step 5: The Return success.
 Peek() or Front() Operation

This operation returns the element at the front end without removing it.
 Rear() Operation

This operation returns the element at the rear end without removing it.
 isEmpty() Operation

This operation returns a boolean value that indicates whether the queue is
empty or not.
 isFull() Operation

This operation returns a boolean value that indicates whether the queue is full or not.
 Types of Queue
Input Restricted Queue:
This is a simple queue. In this type of queue, the input can be taken from only
one end but deletion can be done from any of the ends.

Output Restricted Queue:

This is also a simple queue. In this type of queue, the input can be taken from
both ends but deletion can be done from only one end.
 Circular Queue:
This is a special type of queue where the last position is connected back to the
first position. Here also the operations are performed in FIFO order.

Double-Ended Queue (Dequeue):

In a double-ended queue the insertion and deletion operations, both can be
performed from both ends.

Priority Queue:
A priority queue is a special queue where the elements are accessed based on
the priority assigned to them.
Implementations of Queue
Queue can be implemented using following data structures:

• Implementation of Queue using Structure in C/C++

• Implementation of Queue using Arrays
• Implementation of Queue using Linked List
 Applications of Queue
Application of queue is common. In a computer system, there may be queues of
tasks waiting for the printer, for access to disk storage, or even in a time-
sharing system, for use of the CPU. Within a single program, there may be
multiple requests to be kept in a queue, or one task may create other tasks,
which must be done in turn by keeping them in a queue.

• It has a single resource and multiple consumers.

• It synchronizes between slow and fast devices.
• In a network, a queue is used in devices such as a router/switch and mail queue.
• Variations: dequeue, priority queue and double-ended priority queue.
 Queues are used for what purpose?
In addition to making your data persistent, queues reduce errors that occur when
different parts of your system are down.

What is better, a stack or a queue?

If you want things to come out in the order you put them in, use a queue.
Stacks are useful when you want to reorder things after putting them in.
FIN