Stacks queues-1220971554378778-9

Let’s learn
TACKS & UEUES
for CLASS XII( C++)
SENIOR SECONDARY GROUP
Presented By : NITI ARORA

Introduction to Data Structure
Array and Link list
Stack
Array implementation of Stack
Linked Implementation of Stack
Queue
Array implementation of Queue
Linked Implementation of Queue

A mathematical and logical model of data is known
as Data Structure.

Primitive data structure: The data structure,
which is available in the compiler, is known as a
primitive data structure.
Non-primitive data structure: The data
structure, which is not available in the compiler, is
known as non-primitive data structure.

Linear Data Structure: The data structure in
which each element has access to maximum of one
predecessor element and maximum of one successor
element is known as linear data structure.
Example: Stack, Queue, etc.
Non-linear Data Structure: The data structure in
which each element can access any number of
predecessor elements and any number of successor
elements is known as Non-linear data structure.
Example: Tree, Graphs, etc.

Static Data Structure: The data structure in
which the number of elements is fixed, is known
as Static Data Structure. Example: Arrays
Dynamic Data Structure: The data structure
in which the number of elements is not fixed, is
known as Dynamic Data Structure. Example:
Linked List.

It is a static data structure. It is a
homogeneous collection of data.
The elements in the array are
stored on consecutive memory
locations. Array is also known as
a subscripted variable, e.g., A[i] is
ith
element of the array A.

It is a non-primitive linear data structure in
which insertion and deletion of elements
takes place from only one end, known as top.
It is a non-primitive linear data structure in
which insertion and deletion of elements
takes place from two opposite ends rear
and front respectively.

STACKS
Stacks is LIFO (Last In First Out) structure
and physically can be implemented as an array
or as a linked list.
Stack, when implemented as an array is
functionally same as any other array except that
here, adding an element and deletion is done
from the same direction just like a pile of books.

STACK
Inserting an element in an array is known as PUSH.
Deleting an element from an array is known as POP.
Implementation of STACK in computers
When functions are called.
To convert a infix expression to postfix.
To evaluate a postfix expression.

STACK
A stack is a list in which insertion and deletion takes
place only at one end called top. Thus, called LIFO.
Representation of STACK
data1
data2
data3
data4
TOP
TOP
data4
data3
data2
data1
data1 data2 data3 data4 TOP
TOP data4 data3 data2 data1
Each one of the above has one open and
one close end and data movement takes
place from open end.

Basic operation and
implementation of stacks
• Creation of stack
• Check for empty stack
• Check for full stack
• Add element in stack
• Delete element in stack
• Print stack

STACKS
The fundamental operations that can be performed on
stack are PUSH and POP.
When element is added on the stack top is called PUSH.
And When Data is removed from the stack top, the
operation is called POP.

STACK
The stack operation can be explained as follows:
Stack operation Content of array
Push(a) a
Push (a)
a
Push(b)
b
a
Push( c)
C
b
a
Pop( c)
b
a
Pop(b)
a
Push(b) ba
Push( c) cba
Pop() ba
Pop() a

STACKS
A stack is a list, any list implementation can be used
to implement stack.
We can implement stack by the following data
structures:
Array called Linear Stack
Linked List called Linked Stack

Linear Stack
int S[5];
When PUSH is selected, TOP is incremented,
And data is added at that subscript location
When POP is selected, TOP is decremented,
And data is removed from that subscript location
Stack array
int TOP;
To hold address of
location where data
is inserted or deleted

Lets see working of Linear Stack
8
9
10
Push 7
7
8
9
10
Push 20
20
7
8
9
10
Push 14
OVERFLOW
ARRAY IS FULLTOP
TOP
TOP
Top is incremented
TOP++

CONTINUED….
20
7
8
9
10
Pop 20
7
8
9
10
Pop 7
8
9
10
UNDERFLOW
OCCURS WHEN
STACK IS EMPTY
TOP
Top
Top
TOP is decremented
TOP --

Lets see this using a program
Program Code for the Same is
Click here to execute program
Click here to see program code

A variable which holds an address of a memory
location of another variable is known as a
Pointer Variable (or only pointer).
Example int amt, *p;
amt

900
Requires 2
bytes
0x8ffebab4

0x8ffebab4*P
Requires 2
bytes
Pointer P holds
address of amt

NEW operator in C++ returns the address of
a block of unallocated bytes (depending on
data type a pointer pointing to).
DELETE operator in C++ reverses the process
of new operator, by releasing the memory
location from a pointer. It de allocates
memory assigned by NEW.

A pointer, which stores the address of struct
type data, is known as Pointer to structure.
struct abc
{
int X,Y;
};
struct *g=new abc;
Holds address of dynamic object of struct abc

G

0x8ff134ab
G->X
0x8ff134ab
G->X G->Y
To allocate dynamic allocation
and
store address in point g

struct STACK // structure for stack
{
int data;
STACK *link;
};
struct *TOP;
To hold address of
First node of the list
TOP pointer to holds address of dynamic
objects of link stack.
As we push a node TOP element get shifted
and new node becomes first node.
LIFO implementation every new node becomes
first node.
When we pop Top node is deleted and next
node becomes first node.

Lets see working of Linked stack
* TOP* TOP * Temp
NULL 0x8ffab2e6
A new memory is
allocated and address
is stored in temp
X NULL
data link
0x8ffab2e6
Top = Temp
Top will hold address
of new location
* TOP* TOP
0x8ffab2e6
Thus, TOP will have
this address.
Push operation
Initially top is
assigned NULL
Temp holds
address of new
location

Cont…..
*TOP*TOP
* Temp0x8ffab2e6
0x8ffab2e8
Another new memory is
allocated to an object
Y
data link
0x8ffab2e8
* TOP* TOP
0x8ffab2e8
X NULL
data link
0x8ffab2e6
temp-> link = Top
Top=temp
0x8ffab2e6
Now TOP is
TOP will get shifted
Y becomes first node
X becomes second node

Cont…..
* TOP* TOP * Temp
0x8ffab2e8
0x8ffab2e8
An object is deleted
from top
Y
data link
0x8ffab2e8
Thus Top will be
* TOP* TOP
0x8ffab2e6
X NULL
data link
Temp=TOP
TOP=TOP->link
0x8ffab2e6
delete temp (to release
memory)
0x8ffab2e6
TOP will get shifted
X becomes first node
Y will be released
POP operation

Queues
• Queue is FIFO (First In First Out)
structure and physically can be implemented
as an array or as a linked list.
Queue, when implemented as an array is
functionally same as any other array except that
here, adding an element and deletion is done
from the one direction and deletion from other
just like any queue of peoples.

Queues
• Inserting an element in an array is known as insert.
• Deleting an element from an array is known as delete
But this is done with the help of two parameters rear and
front.
Implementation of queue in computers
When program is executed.

Queue
A Queue is a data structure in which insertion is done
at the end and deletion is done from the front of queue.
It is FIFO .
Representation of Queue
data2
data3
data4
data4
data3
data2
data2 data3 data4
data4 data3 data2
Each one of the above has two open end
Front and Rear. Insertion is done from
Rear and deletion form Front
Rear
Front
Front
Rear
Front Rear
FrontRear

Basic operation and
implementation of QUEUE
• Creation of Queue
• Check for empty Queue
• Check for full Queue
• Add element in Queue
• Delete element in Queue
• Print Queue

QUEUE
Queue are Insert and Delete.
When element is added on the Queue Front is called
Insert.
And When Data is removed from the Queue Rear, the
operation is called Delete.

QUEUE
The Queue operation can be explained as follows:
Queue operation Content of array
Insert(a) Front=0 Rear=0
Insert(b) Front=0 Rear=1
Insert( c) Front=0 Rear=2
Delete() Front=1 Rear=2
a
a b
a b c
b c
c
If we try to insert
Overflow occurs
Though first two cells are empty

Linear Queue
int Q[5];
When INSERT is selected, Rear is incremented,
And data is added at that subscript location
When DELETE is selected, Front is decremented,
And data is removed from that subscript location
Queue array
int Front, Rear;
To hold address of
location where data
is inserted or deleted

QUEUE
A Queue is a list, any list implementation can be
used to implement Queue.
We can implement Queue by the following data
structures:
Array called Linear Queue
Linked List called Linked Queue

Lets see working of LINEAR QUEUE
8
9
10
Insert 7
7
8
9
10
Insert 20
20
7
8
9
10
Insert 14
OVERFLOW
QUEUE is full
Front
rear
rear
rear
Front Front
Rear is incremented
Rear++

Lets see working of Queue as an array
20
7
8
9
10
Delete
20
7
8
9
Delete
20
7
8
Underflow occurs
when QUEUE is
empty
Rear
Front
Rear
Rear
Front
Front
Front is incremented
Front++

struct QUEUE // structure for QUEU
{
int data;
QUEUE *link;
};
struct *Front,*Rear;
To hold address of
First and Last node of the list
Front and Rear pointer to holds address of
dynamic objects of link stack.
As we insert a node Rear element get shifted
and new node becomes next node.
FIFO implementation every new node added at
end.
When we Delete Front node is deleted and next
node becomes first node.

Lets see working of Linked Queue
* Front * Rear* Front * Rear * Temp
NULL NULL 0x8ffab2e6
A new memory is
allocated and address
is stored in temp
X NULL
data link
0x8ffab2e6
Front=Rear = Temp
Front and Rear will
hold address of First
location
* Front * Rear* Front * Rear
0x8ffab2e6 0x8ffab2e6
Thus, Front and Rear will
have this address.
Insert operation
Initially Front and
Rear is assigned
NULL
Temp holds
address of new
location

Cont…..
*Front * Rear*Front * Rear
* Temp
0x8ffab2e8
Another new memory is
allocated to an object
X
data link
0x8ffab2e6
* Rear* Rear
0x8ffab2e8
Y NULL
data link
0x8ffab2e8
temp-> link = Rear
Rear=temp
0x8ffab2e8
Now Rear is
Rear will get shifted
Y becomes Last node

Cont…..
* Front * Rear* Front * Rear * Temp
0x8ffab2e6
An object is deleted
from Front
X
data link
0x8ffab2e6
Thus Front will be
* Front* Front
0x8ffab2e8
Y NULL
data link
Temp=Front
Front=Front->link
0x8ffab2e8
delete temp (to release
memory)
0x8ffab2e8
Front will get shifted
Y becomes first node
X will be released
Delete operation

CIRCULAR QUEUE
Circular Queue are Insert and Delete.
When overflow occurs though the free cells are
available, Rear reaches ends Circular Queue is
implemented to avoid this drawback.
In Circular Queue as soon as Rear reaches maximum
it should reset to 0.

QUEUE
The Queue operation can be explained as follows:
Queue operation Content of array
Insert(a) Front=0 Rear=0
Insert(b) Front=0 Rear=1
Insert( c) Front=0 Rear=2
Insert (d) Front=2 Rear=0
a
a b
a b c
b c
d c
Overflow occurs only when
Array is FULL.
Rear moves to 0 if array is empty

TEST YOUR KNOWLEDGE
• What is difference between Stack & Queue?
• What is Dynamic Allocation?
• What is the significance of Top?
• What is the significance of Front & Rear?
• What is Overflow?
• What is Underflow?
• Where Stack is Implemented?

Stacks queues-1220971554378778-9

More Related Content

What's hot (17)

Viewers also liked (14)

Similar to Stacks queues-1220971554378778-9 (20)

More from Getachew Ganfur (8)

Stacks queues-1220971554378778-9