Data Structures Stack and Queue Data Structures

Department of Computer Science (UG)
Data structures
(24BCA2T421)
Stack and Queue
Dr.Poongothai P
Assistant Professor
Department of Computer Science (UG)
Kristu Jayanti College (Autonomous)
Bengaluru.

UNIT – III
STACK and QUEUE
STACK:
 Stack is a linear data structure that follows a particular order in which the
operations are performed.
 The order may be LIFO(Last In First Out) or FILO(First In Last Out).
 LIFO implies that the element that is inserted last, comes out first
and FILO implies that the element that is inserted first, comes out last.
Example:
 Real-world stack, piles of books, etc.
 A Stack is an abstract data type with a pre-defined capacity, which means
that it can store the elements of a limited size.
 It is a data structure that follows some order to insert and delete the
elements, and that order can be LIFO or FILO.
 Consider a plate stacked over one another in the canteen. The plate which is
at the top is the first one to be removed, i.e. the plate which has been
placed at the bottommost position remains in the stack for the longest
period of time.

Working of Stack:
 Stack works on the LIFO pattern.
 Example there are five memory blocks in the stack; therefore, the size of
the stack is 5.
 Suppose we want to store the elements in a stack and let's assume
that stack is empty.
 We have taken the stack of size 5 as shown below in which we are pushing
the elements one by one until the stack becomes full.
Stack Operations:
The following are some common operations implemented on the stack:
 push(): When we insert an element in a stack then the operation is known
as a push. If the stack is full then the overflow condition occurs.

 pop(): When we delete an element from the stack, the operation is known as
a pop. If the stack is empty means that no element exists in the stack, this
state is known as an underflow state.
 isEmpty(): It determines whether the stack is empty or not.
 isFull(): It determines whether the stack is full or not.'
 peek(): It returns the element at the given position.
 count(): It returns the total number of elements available in a stack.
 change(): It changes the element at the given position.
 display(): It prints all the elements available in the stack.
Stack Implementation:
PUSH operation:
The steps involved in the PUSH operation are given below:
 Before inserting an element in a stack, we check whether the stack is full.
 If we try to insert the element in a stack, and the stack is full, then
the overflow condition occurs.
 When we initialize a stack, we set the value of top as -1 to check that
the stack is empty.
 When the new element is pushed in a stack, first, the value of the top gets
incremented, i.e., top=top+1, and the element will be placed at the new
position of the top.
 The elements will be inserted until we reach the max size of the stack.

POP operation:
The steps involved in the POP operation are given below:
 Before deleting the element from the stack, we check whether the stack is
empty.
 If we try to delete the element from the empty stack,
then
the underflow condition occurs.
 If the stack is not empty, we first access the element which is pointed by
the top
 Once the pop operation is performed, the top is decremented by 1,
i.e., top=top-1.

Stack Notations
Following is the various Applications of Stack in Data Structure:
 Evaluation of Arithmetic Expressions
 Backtracking
 Delimiter Checking
 Reverse a Data
 Processing Function Calls
1. Evaluation of Arithmetic Expressions
 An arithmetic expression consists of operands and operators.
 In addition to operands and operators, the arithmetic expression may
also include parenthesis like "left parenthesis" and "right parenthesis".

Example: A + (B - C)
To evaluate the expressions, the precedence rules for the five basic arithmetic
operators are:
Operators Associativity Precedence
^ exponentiation Right to left
Highest followed by *Multiplication
and /division
*Multiplication, /division Left to right
Highest followed by + addition and
– subtraction
+ addition, - subtraction Left to right Lowest
Evaluation of Arithmetic Expression requires two steps:
 First, convert the given expression into special notation.
 Evaluate the expression in this new notation.
Notations for Arithmetic Expression
There are three notations to represent an arithmetic expression:
 Infix Notation
 Prefix Notation
 Postfix Notation
Infix Notation
 The infix notation is an expression in which each operator is placed between
the operands.
 Infix expressions can be parenthesized or unparenthesized depending upon
the problem requirement.

 Example: A + B, (C - D) etc.
 All these expressions are in infix notation because the operator comes
between the operands.
Prefix Notation
 The prefix notation places the operator before the operands and hence often
referred to as polish notation.
 Example: + A B, -CD etc.
 All these expressions are in prefix notation because the operator comes
before the operands.
Postfix Notation
 The postfix notation places the operator after the operands.
 This notation is just the reverse of Polish notation and also known as
Reverse Polish notation.
 Example: AB +, CD+, etc.
 All these expressions are in postfix notation because the operator comes
after the operands.
Conversion of Arithmetic Expression into various Notations:
Infix Notation Prefix Notation Postfix Notation
A * B * A B AB*
(A+B)/C /+ ABC AB+C/
(A*B) + (D-C) +*AB - DC AB*DC-+

Evaluating Postfix expression:
Before evaluating the postfix expression, the following conditions must be
checked. If any one of the conditions fails, the postfix expression is invalid.
 When an operator encounters the scanning process, the Stack must contain a
pair of operands or intermediate results previously calculated.
 When an expression has been completely evaluated, the Stack must contain
exactly one value.

Algorithm for STACK:
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 5
// Stack structure
typedef struct {
int items[MAX_SIZE];
int top;
} Stack;
// Function to initialize
the stack
void init(Stack *stack) {
stack->top = -1;
}
// Function to check if
the stack is full
int isFull(Stack *stack)
{
return stack->top ==
MAX_SIZE - 1;
}
// Function to check if
the stack is empty
int isEmpty(Stack *stack) {
return stack->top == -1;
}
// Function to push an
element onto the stack
void push(Stack *stack, int value) {
if (isFull(stack)) {

return;
}
stack->top++;
stack->items[stack->top] = value;
printf("Pushed %dn", value);
}
// Function to pop an element
from the stack
int pop(Stack *stack) {
int item;
if (isEmpty(stack))
{ printf("Stack is empty
n");
return -1;
}
item = stack->items[stack->top];
stack->top--;
return item;
}
// Function to peek at the top
element of the stack
int peek(Stack *stack) {
if (isEmpty(stack)) {
printf("Stack is emptyn");
return -1;
}
return stack->items[stack-
>top];
}

int main()
{ Stack
stack;
init(&stack);
push(&stack,
1);
push(&stack,
2);
push(&stack,
3);
push(&stack,
4);
push(&stack,
5);
push(&stack,
6); // Stack
is full
printf("Peeked
element:
%dn",
peek(&stack
)); //
Output: 5
printf("Popped element: %dn", pop(&stack)); // Output: 5
printf("Popped element: %dn", pop(&stack)); // Output: 4
return 0;
}

Queue Data Structure
 A Queue Data Structure is used for storing and managing data in a
specific order.
 It follows the principle of “First in, First out” (FIFO), where the first
element added to the queue is the first one to be removed.
 Queues are commonly used in various algorithms and applications for
their simplicity and efficiency in managing data flow.
FIFO Principle of Queue:
 A Queue is like a line waiting to purchase tickets, where the first person in
line is the first person served. (i.e. First come first serve).
 Position of the entry in a queue ready to be served, that is, the first entry that
will be removed from the queue, is called the front of the
queue(sometimes, head of the queue), similarly, the position of the last entry
in the queue, that is, the one most recently added, is called the rear (or
the tail) of the queue.

Characteristics of Queue:
 Queue can handle multiple data.
 We can access both ends.
 They are fast and flexible.
Basic Operations on Queue:
Some of the basic operations for Queue in Data Structure are:
 enqueue() – Insertion of elements to 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.
 isEmpty() – Checks if the queue is empty.
 size(): This operation returns the size of the queue i.e. the total number of
elements it contains.

Operation 1: enqueue()
 Inserts an element at the end of the queue i.e. at the rear end.
The following steps should be taken to enqueue (insert) data into a queue:
o Check if the queue is full.
o If the queue is full, return overflow error and exit.
o If the queue is not full, increment the rear pointer to point to the
next empty space.
o Add the data element to the queue location, where the rear is pointing.
o return success.

// Function to add an item to the queue.
// It changes rear and size
void enqueue(struct Queue* queue, int item)
{
if (isFull(queue))
return;
queue->rear = (queue->rear + 1) % queue->capacity;
queue->array[queue->rear] = item;
queue->size = queue->size + 1;
printf("%d enqueued to queuen", item);
}

Complexity Analysis:
 Time Complexity: O(1)
 Space Complexity: O(N)
Operation 2: dequeue()
This operation removes and returns an element that is at the front end of
the queue.
The following steps are taken to perform the dequeue operation:
 Check if the queue is empty.
 If the queue is empty, return the underflow error and exit.
 If the queue is not empty, access the data where the front is pointing.
 Increment the front pointer to point to the next available data element.
 The Return success.

// Function to remove an item from queue.
// It changes front and size
int dequeue(struct Queue* queue)
{
if (isEmpty(queue)) { printf("
nQueue is emptyn");
return;
}
int item = queue->array[queue->front];
queue->front = (queue->front + 1) % queue->capacity;
queue->size = queue->size - 1;
return item;
}
Operation 3: front()
This operation returns the element at the front end without removing
it. The following steps are taken to perform the front operation:
 If the queue is empty return the most minimum value.
 otherwise, return the front value.
// Function to get front of queue

int front(struct Queue* queue)
{
if (isempty(queue))
return INT_MIN;
return queue->arr[queue->front];
}
Operation 4 : rear()
This operation returns the element at the rear end without removing
it. The following steps are taken to perform the rear operation:
 If the queue is empty return the most minimum value.
 otherwise, return the rear value.
// Function to get rear of queue
int front(struct Queue* queue)
{
if (isempty(queue))
return INT_MIN;
return queue->arr[queue->rear];
}

Operation 5: isEmpty():
This operation returns a boolean value that indicates whether the queue is empty or
not.
The following steps are taken to perform the Empty operation:
 check if front value is equal to -1 or not, if yes then return true means queue
is empty.
 Otherwise return false, means queue is not empty
// Queue is empty when size is 0
bool isEmpty(struct Queue* queue)
{
return (queue->size == 0);
}
Operation 6 : isFull()
This operation returns a boolean value that indicates whether the queue is full or
not.
The following steps are taken to perform the isFull() operation:
 Check if front value is equal to zero and rear is equal to the capacity of
queue if yes then return true.
 otherwise return false

// Queue is full when size becomes equal to the capacity
bool isFull(struct Queue* queue)
{
return (queue->size == queue->capacity);
}
Operation 7: size()
This operation returns the size of the queue i.e. the total number of elements it
contains.
queuename.size()
Parameters : No parameters are passed
Returns : Number of elements in the container

Types of Queue:
There are four different types of queue that are listed as follows -
o Simple Queue or Linear Queue
o Circular Queue
o Priority Queue
o Double Ended Queue (or Deque)
Simple Queue or Linear Queue:
 In Linear Queue, an insertion takes place from one end while the deletion
occurs from another end.
 The end at which the insertion takes place is known as the rear end, and the
end at which the deletion takes place is known as front end.
 It follows the FIFO rule.

 The major drawback of using a linear Queue is that insertion is done only
from the rear end.
 If the first three elements are deleted from the Queue, we cannot insert more
elements even though the space is available in a Linear Queue.
 In this case, the linear Queue shows the overflow condition as the rear is
pointing to the last element of the Queue.
Algorithm for Linear Queue:
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 5
// Linear Queue
structure
typedef struct {
int front, rear;
} LinearQueue;
// Function to initialize the linear queue
void init(LinearQueue *queue) {
queue->front = -1;
queue->rear = -1;
}
// Function to check if the queue is full
int isFull(LinearQueue *queue) {

return queue->rear == MAX_SIZE - 1;
}
// Function to check if the queue is empty
int isEmpty(LinearQueue *queue) {
return queue->front == -1;
}
// Function to add an element to the
queue
void enqueue(LinearQueue *queue, int value) {
if (isFull(queue)) {
printf("Queue is fulln");
return;
}
if (isEmpty(queue)) {
queue->front = 0;
}
queue->rear++;
queue->items[queue->rear] = value;
printf("Inserted %dn", value);
}
// Function to remove an element from the queue
int dequeue(LinearQueue *queue) {

int item;
if (isEmpty(queue))
{ printf("Queue is empty
n"); return -1;
}
item = queue->items[queue->front];
if (queue->front == queue->rear) {
queue->front = -1;
queue->rear = -1;
} else {
queue->front++;
}
return item;
}
// Function to display the elements of the queue
void display(LinearQueue *queue) {
printf("Queue is emptyn");
return;
}
printf("Front -> ");

for (int i = queue->front; i <= queue->rear; i++) {
printf("%d -> ", queue->items[i]);
}
printf("Rearn");
}
int main() {
LinearQueue queue;
init(&queue);
enqueue(&queue, 1);
enqueue(&queue, 2);
enqueue(&queue, 3);
enqueue(&queue, 4);
enqueue(&queue, 5);
enqueue(&queue, 6); // Queue is full
display(&queue); // Output: 1 -> 2 -> 3 -> 4 -> 5 -> Rear
printf("Deleted element: %dn", dequeue(&queue));
display(&queue); // Output: 3 -> 4 -> 5 -> Rear
enqueue(&queue, 6);
display(&queue); // Output: 3 -> 4 -> 5 -> 6 -> Rear
return 0; }

Circular Queue:
 In Circular Queue, all the nodes are represented as circular.
 It is similar to the linear Queue except that the last element of the queue is
connected to the first element.
 It is also known as Ring Buffer, as all the ends are connected to another
end.
 The drawback that occurs in a linear queue is overcome by using the
circular queue.
 If the empty space is available in a circular queue, the new element can
be added in an empty space by simply incrementing the value of rear.
 The main advantage of using the circular queue is better memory
utilization.
Example of Circular Queue:

Data Structures Stack and Queue Data Structures

Algorithm of Circular Queue:
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 5
// Circular Queue structure
typedef struct {
int front, rear;
} CircularQueue;
// Function to initialize the circular queue
void init(CircularQueue *queue) {
queue->front = -1;
queue->rear = -1;
}
// Function to check if the queue is full
int isFull(CircularQueue *queue) {
return (queue->front == 0 &&
queue->rear == MAX_SIZE - 1) ||
(queue->rear
== (queue->front - 1) % (MAX_SIZE
- 1));
}
// Function to check if the queue is empty
int isEmpty(CircularQueue *queue) {
return queue->front == -1;
}
// Function to add an element to the
queue
void enqueue(CircularQueue *queue, int value) {
if (isFull(queue)) {

printf("Queue is full
n"); return;
}
queue->front = 0;
queue->rear = 0;
} else {
queue->rear =
(queue->rear + 1)
% MAX_SIZE;
}
queue->items[queue->rear] = value;
printf("Inserted %dn", value);
}
// Function to remove an element from the queue
int dequeue(CircularQueue *queue) {
int item;
if (isEmpty(queue))
n"); return -1;
}
if (queue->front == queue-
>rear) {
queue->front = -1;
queue->rear = -1;
} else {

queue->front = (queue->front + 1) % MAX_SIZE;
}
return item;
}
// Function to display the elements of the queue
void display(CircularQueue *queue) {
if (isEmpty(queue))
n"); return;
}
printf("Front -> ");
for (int i = queue->front; i != queue->rear; i = (i + 1) % MAX_SIZE) {
printf("%d -> ", queue->items[i]);
}
printf("%d -> Rearn", queue->items[queue->rear]);
}
int main() {
CircularQueue queue;
init(&queue);
enqueue(&queue, 1);
enqueue(&queue, 2);
enqueue(&queue, 3);
enqueue(&queue, 4);
enqueue(&queue, 5);
enqueue(&queue, 6); // Queue is full

display(&queue); // Output: 1 -> 2 -> 3 -> 4 -> 5 -> Rear
display(&queue); // Output: 3 -> 4 -> 5 -> Rear
enqueue(&queue, 6);
display(&queue); // Output: 3 -> 4 -> 5 -> 6 -> Rear
return 0;
}

Data Structures Stack and Queue Data Structures

Recommended

More Related Content

Similar to Data Structures Stack and Queue Data Structures (20)

More from poongothai11 (9)

Recently uploaded (20)

Data Structures Stack and Queue Data Structures