Stacks and Queue - Data Structures

Data Structures
1 Dr.G.Jasmine Beulah
BCA204A21: DATA STRUCTURES
Dr. G. Jasmine Beulah
Dept. Computer Science,
Kristu Jayanti College(UG)
Bengaluru

Stack
Stack - Definition; Array representation of stack; Operations on
stack; Polish notation; Reverse Polish notation; Applications of
stack, Conversion of an infix arithmetic expression to postfix,
Evaluation of postfix expression

Today’s discussion…
3
*Stack
*Basic principles
*Operation of stack
*Stack using Array
*Applications of stack
Dr.G.Jasmine Beulah

Stack

Basic Idea
• 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 Representation
• Can be implemented by means of Array, Structure, Pointers and
Linked List.
• Stack can either be a fixed size or dynamic.

7
STACK
push
create
pop
isfull
isempty
Dr.G.Jasmine Beulah
Operations

STACK: Last-In-First-Out (LIFO)
*An abstract data type (ADT) is an abstraction of a data structure
*An ADT specifies:
*Data stored
*Operations on the data
8
Assumption: stack contains integer elements!
Dr.G.Jasmine Beulah

Objects:
* A finite sequence of nodes
Operations:
*Create
*push(): Insert element at top on the stack
*peek(): Return top element without removing it
*pop(): Remove and return top element
*isEmpty(): check if stack is empty
*isfull() : test if stack is full
*Stack ADT
Dr.G.Jasmine Beulah
BCA204A21: DATA STRUCTURES 9

Stack using Array

11
top
top
PUSH
Push using Stack
Dr.G.Jasmine Beulah

12
top
top
POP
Pop using Stack
Dr.G.Jasmine Beulah

• In the array implementation, we would:
• Declare an array of fixed size (which determines the maximum
size of the stack).
• Keep a variable which always points to the “top” of the stack.
• Contains the array index of the “top” element.
13
Basic Idea
Dr.G.Jasmine Beulah

Declaration & Stack Creation
14
#define MAXSIZE 10
int stack[MAXSIZE];
int top =-1;
ARRAY
Dr.G.Jasmine Beulah

Checking for Stack Full
15
int isfull()
{
if(top == MAXSIZE)
return 1;
else
return 0;
}
ARRAY
Dr.G.Jasmine Beulah

Checking for stack empty
16
int isempty ()
{
if (top == -1)
return 1;
else
return (0);
}
ARRAY
Dr.G.Jasmine Beulah

Pushing an element into stack
17
int push(int data)
{
if(!isfull())
{
top = top + 1;
stack[top] = data;
}
else
{
printf("Could not insert
data, Stack is full.n");
}
}
ARRAY
Dr.G.Jasmine Beulah

Popping an element from stack
18
int pop()
{
int data;
if(!isempty())
{
data = stack[top];
top = top - 1;
return data;
}
else
{
printf("Could not retrieve data,
Stack is empty.n");
}
}
ARRAY
Dr.G.Jasmine Beulah

Example: A Stack using an Array
19
#include <stdio.h>
#define MAXSIZE 100
struct lifo
{
int st[MAXSIZE];
int top;
};
typedef struct lifo stack;
main() {
stack A, B;
create(&A);
create(&B);
push(&A,10);
push(&A,20);
push(&A,30);
push(&B,100);
push(&B,5);
printf (“%d %d”, pop(&A), pop(&B));
push (&A, pop(&B));
if (isempty(&B))
printf (“n B is empty”);
return;
}
Dr.G.Jasmine Beulah

Applications of Stacks
• Direct applications:
• Page-visited history in a Web browser
• Undo sequence in a text editor
• Saving local variables when one function calls another, and this one
calls another

Dr.G.Jasmine Beulah
BCA204A21: DATA STRUCTURES 21
*

Notation
*The way to write arithmetic expression is known as a notation.
*An arithmetic expression can be written in three different but equivalent
notations, i.e., without changing the essence or output of an expression.
*These notations are −
Infix Notation
Prefix (Polish) Notation
Postfix (Reverse-Polish) Notation

Infix Notation
*In an Infix Notation, operators are used in-between operands.
*e.g. a - b + c, where operators are used in-between operands.
* Humans can easily read, write, and speak in infix notation but the same
does not go well with computing devices.

Prefix Notation
*In the Prefix notation, operator is prefixed to operands, i.e. operator is
written ahead of operands.
*For example, +ab. This is equivalent to its infix notation a + b.
*Prefix notation is also known as Polish Notation

Postfix Notation
*Postfix notation is also known as Reversed Polish Notation
*In the Postfix notation style, the operator is post-fixed to the operands
i.e., the operator is written after the operands.
*For example, ab+
*This is equivalent to its infix notation a + b.

A simple example to show the difference of
the three Notation

Infix and Postfix Notations
• Infix: operators placed between operands:
A+B*C
• Postfix: operands appear before their operators:-
ABC*+
• There are no precedence rules to learn in postfix notation, and
parentheses are never needed

Infix Postfix
A + B A B +
A + B * C A B C * +
(A + B) * C A B + C *
A + B * C + D A B C * + D +
(A + B) * (C + D) A B + C D + *
A * B + C * D A B * C D * +
A + B * C  (A + (B * C))  (A + (B C *) )  A B C * +
A + B * C + D  ((A + (B * C)) + D )  ((A + (B C*) )+ D) 
((A B C *+) + D)  A B C * + D +
28
Infix to Postfix
Dr.G.Jasmine Beulah

Infix to postfix conversion
• Use a stack for processing operators (push and pop operations).
• Scan the sequence of operators and operands from left to right and
perform one of the following:
• output the operand,
• push an operator of higher precedence,
• pop an operator and output, till the stack top contains operator of a lower
precedence and push the present operator.
BCA204A21: DATA STRUCTURES 29 Dr.G.Jasmine Beulah

The Algorithm Steps…
1. Print operands as they arrive.
2. If the stack is empty or contains a left parenthesis on top, push the incoming operator
onto the stack.
3. If the incoming symbol is a left parenthesis, push it on the stack.
4. If the incoming symbol is a right parenthesis, pop the stack and print the operators
until you see a left parenthesis. Discard the pair of parentheses.
5. If the incoming symbol has higher precedence than the top of the stack, push it on the
stack.
6. If the incoming symbol has equal precedence with the top of the stack, use association.
If the association is left to right, pop and print the top of the stack and then push the
incoming operator. If the association is right to left, push the incoming operator.
7. If the incoming symbol has lower precedence than the symbol on the top of the stack,
pop the stack and print the top operator. Then test the incoming operator against the
new top of stack.
8. At the end of the expression, pop and print all operators on the stack. (No parentheses
should remain.)

Infix to Postfix Conversion
Requires operator precedence information
Operands:
Add to postfix expression.
Close parenthesis:
pop stack symbols until an open parenthesis appears.
Operators:
Pop all stack symbols until a symbol of lower precedence appears. Then push
the operator.
End of input:
Pop all remaining stack symbols and add to the expression.

Current
symbol
Operator
Stack
Postfix string
1 A A
2 * * A
3 ( * ( A
4 B * ( A B
5 + * ( + A B
6 C * ( + A B C
7 * * ( + * A B C
8 D * ( + * A B C D
9 ) * A B C D * +
10 + + A B C D * + *
11 E + A B C D * + * E
12 A B C D * + * E +
Expression:
A * (B + C * D) + E
becomes
A B C D * + * E +
Postfix notation
is also called as
Reverse Polish
Notation (RPN)
32
Infix to Postfix Rules
Dr.G.Jasmine Beulah

Queue :
Queue

Basic Idea(FIFO)
• 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).

1. A queue can be defined as an ordered list which enables insert
operations to be performed at one end called REAR and delete
operations to be performed at another end called FRONT.
2. Queue is referred to be as First In First Out list.
3. For example, people waiting in line for a rail ticket form a queue.
Queue (FIFO)

Queue Representation
• As in stacks, a queue can also be implemented using Arrays, Linked-
lists, Pointers and Structures.

QUEUE
enqueue
create
dequeue
size
isempty
Operations of Queue

Array representation of Queue
 Represent queue by using Linear Arrays.
 There are two variables i.e. front and rear, that are implemented in the case of every
queue.
 Front and rear variables point to the position from where insertions and deletions are
performed in a queue.
 Initially, the value of front and queue is -1 which represents an empty queue.
Initial:
int front =-1
int rear = -1;

Queue Insertion
Points to remember when we add an element in the queue:
 Check whether the queue has any space to add an element into it.
 If the queue has spaces then add the element into the queue by incrementing the REAR
pointer.
 Example: Increment the REAR as REAR+1 or REAR++
 Queue [Rear] = Item which is used to add an element into the queue
 Note: Rear is the position where the item is to be inserted.
void qinsert()
{
int item;
if(rear==max-1)
printf("Queue is full");
else
{
printf("Enter the value to
insertn");
scanf("%d",&item);
rear++;
queue[rear]=item;
} }

Queue Overflow
 Insertion of an element in a queue is possible only if there is room in the array to fit
in elements.
 If the maximum size of the array is reached and if an attempt to insert an element
into the queue that is full, is tried, the condition that occurs is called ‘queue
overflow’.
 A function to check whether queue is full or not returns 1 when the queue is full and
returns 0 when the queue is not full.
 This function is used to check for queue overflow.
 A queue is full when REAR reaches the maximum size of the array used for the
queue i.e. REAR=max-1. FRONT = 0 and REAR = n-1 indicates this condition.
int qfull( )
{
if(rear = = max-1)
return 1;
else
return 0;
}

Deletion of element from the queue:
Points to remember when we remove an element from the queue:
 Check whether the queue has any element to be deleted.
 If so, delete the element from the queue by incrementing the FRONT
pointer. Example: Item= queue[rear]
 Increment the front using front++
 Note: Rear is the position where the item is to be inserted.
void qdelete()
{
int item;
if(front==rear+1)
printf("Queue is
empty");
else
{
item=queue[front];
printf("%d is
deletedn",item);
front++;
}
}

Queue Underflow
 Deletion or removal of an element from the queue can be done only if at least one
item is there in the queue.
 It means that the queue must be non-empty. An attempt to remove an element from
an empty queue is called ‘queue underflow’.
 A function to check whether queue is empty or not return 1 when the queue is empty
and returns 0 when the queue is not empty.
This function is used to check for queue underflow.
int qempty()
{
if(front == rear+1)
return 1;
else return 0;
}

Queue display
 After deleting an element, the value of front will increase from -1 to 0.
 however, the queue will look something like following.
void qdisplay()
{
int item;
int p=front;
if(p==rear+1)
printf("Queue is empty");
else
{
printf("nQueue Elements");
while(p<=rear)
{
printf("%dt",queue[p]);
p++;
}
}
}

Types of Queue

Disadvantage of Linear Queue:
 Using array to implement the queue, will create a problem when the queue is full –
memory space are fixed.
Problem solution
Create a circular queue.
Circular queue wraps around to the
beginning whenever the Head(Front) or the
Tail(Rear) reaches the end of the queue.

Circular Queue:
 The method of arranging the queue elements Q[1], Q[2], …….. Q[n] in a circular fashion
with Q[1] following Q[n] is called Circular Queue.
 A circular queue is similar to a linear queue as it is also based on the FIFO (First
In First Out) principle except that the last position is connected to the first position
in a circular queue that forms a circle.
 It is also known as a Ring Buffer.

Circular Queue:
Enqueue operation
The steps of enqueue operation are given below:
 First, we will check whether the Queue is full or not.
 Initially the front and rear are set to -1. When we insert the first element in a Queue, front
and rear both are set to 0.
 When we insert a new element, the rear gets incremented, i.e., rear=rear+1.
Let's understand the enqueue and dequeue operation through the
diagrammatic representation.

Circular Queue:

Circular Queue:
void insert(int ele)
{
if(front==rear+1)||(rear==size-1)
{
printf(“Cqueue is full”);
}
elseif(front==-1 && rear==-1)
{
front=rear=0;
cqueue[rear]=ele;
rear++;
}
else if(rear=size-1)
{
rear=0;
cqueue[rear]=ele;
}
else { rear++;
cqueue[rear]=ele;
}
void delete()
{
if(front==-1 && rear==-1)
{
printf(“Cqueue is empty”);
}
elseif(front==rear)
{
ele=cqueue[front];
front=rear-1;
else
{
ele=cqueue[front];
front++;
}
elseif(front=size-1)
{
ele=cqueue[front];
front=0;
}
else { ele=cqueue[front];

Priority Queue:
 A Queue in which it is able to insert elements or remove elements
from any position on some property (such as priority of the task to
be processed) is referred as priority Queue.
 An element of higher priority is processed before any element of
lower priority.
 Two elements with the same priority are processed according to
the order in which they were added to the queue.
 In priority queue, every element has been assigned with a priority
value called priority.
 The elements can be inserted or deleted randomly any where in
the queue. Priority queue is a data structure in which prioritized
insertion and deletion operations on elements can be performed
according to their priority values.

Priority Queue:

Ascending Priority Queue:
 In this queue, elements can be inserted randomly. The smallest
element of the queue is deleted first.
 If elements with equal priority are present, the FIFO technique
is applied.

Descending Priority Queue:
 In this queue, elements can be inserted randomly.
 The largest element of the queue is deleted first.
 If elements with equal priority are present, the FIFO technique
is applied

Double Ended Queue
A dequeue, also known as a double-ended queue, is an
ordered collection of items similar to the queue.
It has two ends, a front and a rear, and the items remain
positioned in the collection.
What makes a dequeue different is the unrestrictive
nature of adding and removing items.
New items can be added at either the front or the rear.
Likewise, existing items can be removed from either
end.
In a sense, this hybrid linear structure provides all the
capabilities of stacks and queues in a single data
structure.

Double Ended Queue
 A deque is structured, as described above, as an ordered
collection of items where items are added and removed
from either end, either front or rear. The deque
operations are given below.

Double Ended Queue
 deque() creates a new deque that is empty. It needs no parameters
and returns an empty deque.
 add_front(item) adds a new item to the front of the deque. It needs
the item and returns nothing.
 add_rear(item) adds a new item to the rear of the deque. It needs
the item and returns nothing.
 remove_front() removes the front item from the deque. It needs no
parameters and returns the item. The deque is modified.
 remove_rear() removes the rear item from the deque. It needs no
parameters and returns the item. The deque is modified.
 is_empty() tests to see whether the deque is empty. It needs no
parameters and returns a boolean value.
 size() returns the number of items in the deque. It needs no
parameters and returns an integer.

Applications of Queue:
1. One of the classical areas to which queues can be applied is
simulation. (Simulation is a process of forming an abstract model
from a real situation in order to understand the impact of
modifications and the effect of introducing various strategies on
the situation)
2. Queues find their application in CPU scheduling, in printer
spooling, in message queuing in computer network.

Stacks and Queue - Data Structures

More Related Content

What's hot (20)

Similar to Stacks and Queue - Data Structures (20)

More from Dr. Jasmine Beulah Gnanadurai (20)

Recently uploaded (20)

Stacks and Queue - Data Structures