PROGRAMMING AND DATA

STRUCTURES

DEBASIS SAMANTA
COMPUTER SCIENCE & ENGINEERING

INDIAN INSTITUTE OF TECHNOLOGY KHARAGPUR

SPRING-2017
 CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

Lecture #13
Stack & Queue
TODAY’S DISCUSSION…
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

*Stack • Queue
• Basic principles
* Basic principles
• Operation of queue
* Operation of stack • Queue using Array
* Stack using Array • Queue using Linked List
• Applications of queue
* Stack using Linked List
* Applications of stack
 CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

STACK
BASIC IDEA
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

5
• 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
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

• Can be implemented by means of Array, Structure, Pointers and Linked List.

• Stack can either be a fixed size or dynamic.
 CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

7
push

pop

create
STACK
isempty

isfull
STACK: LAST-IN-FIRST-OUT (LIFO)
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

8
• void push (stack *s, int element);
/* Insert an element in the stack */
• int pop (stack *s);
/* Remove and return the top element */
• void create (stack *s);
/* Create a new stack */
• int isempty (stack *s);
/* Check if stack is empty */
• int isfull (stack *s);
/* Check if stack is full */
Assumption: stack contains integer elements!
 CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

STACK USING ARRAY

Push using Stack
Autumn 2016 Autumn 2016

10

PUSH

top
top
Pop using Stack
Autumn 2016 Autumn 2016

11

POP

top
top
 CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

12

STACK USING LINKED LIST

Push using Linked List
Autumn 2016 Autumn 2016

13

PUSH OPERATION

top
Pop using Linked List
Autumn 2016 Autumn 2016

14

POP OPERATION

top
Basic Idea Autumn 2016 Autumn 2016

15

• 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.

• In the linked list implementation, we would:

• Maintain the stack as a linked list.
• A pointer variable top points to the start of the list.
• The first element of the linked list is considered as the stack top.
DECLARATION
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

16

#define MAXSIZE 100 struct lifo

{
struct lifo int value;
{ struct lifo *next;
int st[MAXSIZE]; };
int top; typedef struct lifo
}; stack;
typedef struct lifo
stack; stack *top;
stack s;

ARRAY LINKED LIST

STACK CREATION
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

17

void create (stack *s) void create (stack **top)

{ {
s->top = -1; *top = NULL;
/* s->top points to /* top points to NULL,
last element indicating empty
pushed in; stack */
initially -1 */ }
}

ARRAY LINKED LIST

 PUSHING AN ELEMENT INTO STACK
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

18

void push (stack *s, int element) void push (stack **top, int element)
{ {
stack *new;
if (s->top == (MAXSIZE-1))
{ new = (stack *)malloc
printf (“\n Stack (sizeof(stack));
overflow”); if (new == NULL)
exit(-1); {
} printf (“\n Stack is full”);
exit(-1);
else
}
{
s->top++; new->value = element;
s->st[s->top] = element; new->next = *top;
} *top = new;
}
}

ARRAY LINKED LIST

POPPING AN ELEMENT FROM STACK
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

19

int pop (stack **top)

int pop (stack *s) {
int t;
{ stack *p;
if (s->top == -1)
if (*top == NULL)
{ {
printf (“\n Stack printf (“\n Stack is empty”);
underflow”); exit(-1);
exit(-1); }
else
}
{
else t = (*top)->value;
{ p = *top;
return (s->st[s->top--]); *top = (*top)->next;
} free (p);
return t;
} }
}

ARRAY LINKED LIST

CHECKING FOR STACK EMPTY
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

20

int isempty (stack *s) int isempty (stack *top)

{ {
if (s->top == -1) if (top == NULL)
return 1; return (1);
else else
return (0); return (0);
} }

ARRAY LINKED LIST

CHECKING FOR STACK FULL
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

21

int isempty (stack *s) int isempty (stack *top)

{ {
if (s->top == -1) if (top == NULL)
return 1; return (1);
else else
return (0); return (0);
} }

ARRAY LINKED LIST

EXAMPLE: A STACK USING AN ARRAY
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

22
#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;
}
EXAMPLE: A STACK USING LINKED
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

LIST
23
#include <stdio.h>
struct lifo
{
int value;
struct lifo *next;
};
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;
}
APPLICATIONS OF STACKS
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

24
• Direct applications:
• Page-visited history in a Web browser
• Undo sequence in a text editor
• Chain of method calls in the Java Virtual Machine
• Validate XML

• Indirect applications:
• Auxiliary data structure for algorithms
• Component of other data structures
INFIX AND POSTFIX NOTATIONS
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

25
• 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 TO POSTFIX
Autumn 2016

26

Infix Postfix
A+B AB+
A+B*C ABC*+
(A + B) * C AB+C*
A+B*C+D ABC*+D+
(A + B) * (C + D) AB+CD+*
A*B+C*D AB*CD*+

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 +
INFIX TO POSTFIX CONVERSION
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

27
• 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.
THE ALGORITHM STEPS
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

28
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
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

29
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.
Infix to Postfix Rules
Autumn 2016

30

Current Operator Postfix string

Expression: symbol Stack
1 A A
A * (B + C * D) + E
2 * * A
3 ( *( A
becomes
4 B *( AB
ABCD*+*E+ 5 + *(+ AB
6 C *(+ ABC
7 * *(+* ABC
8 D *(+* ABCD
Postfix notation
is also called as 9 ) * ABCD*+
Reverse Polish 10 + + ABCD*+*
Notation (RPN) 11 E + ABCD*+*E
12 ABCD*+*E+
 CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

31

QUEUE
BASIC IDEACS 11001 : Programming and Data Structures Lecture #00: © DSamanta

32
• 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 REPRESENTATION
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

33

• As in stacks, a queue can also be implemented using Arrays, Linked-lists,

Pointers and Structures.
 CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

34enqueue

dequeue

create
QUEUE
isempty

size
QUEUE: First-In-First-Out (LIFO)
void enqueue (queue *q, int element);
/* Insert an element in the queue */
int dequeue (queue *q);
/* Remove an element from the queue */
queue *create();
/* Create a new queue */
int isempty (queue *q);
/* Check if queue is empty */
int size (queue *q);
/* Return the no. of elements in queue */
Assumption: queue contains integer elements!

35
Autumn 2016 Autumn 2016
 CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

36

QUEUE USING LINKED LIST

Basic Idea Autumn 2016 Autumn 2016

37

• Basic idea:
• Create a linked list to which items would be added to one end and
deleted from the other end.
• Two pointers will be maintained:
• One pointing to the beginning of the list (point from where
elements will be deleted).
• Another pointing to the end of the list (point where new Rear
elements will be inserted).

Front DELETION INSERTION

QUEUE: LINKED LIST STRUCTURE
Autumn 2016 Autumn 2016

38

ENQUEUE

front rear
QUEUE: LINKED LIST STRUCTURE
Autumn 2016 Autumn 2016

39

DEQUEUE

front rear
EXAMPLE :QUEUE USING LINKED LIST
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

40
struct qnode
{
int val;
struct qnode *next;
};

struct queue
{
struct qnode *qfront, *qrear;
};
typedef struct queue QUEUE;

void enqueue (QUEUE *q,int element)

{
struct qnode *q1;
q1=(struct qnode *)malloc(sizeof(struct qnode));
q1->val= element;
q1->next=q->qfront;
q->qfront=q1;
}
EXAMPLE :QUEUE USING LINKED LIST
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

41
int size (queue *q)
{
queue *q1;
int count=0;
q1=q;
while(q1!=NULL) int dequeue (queue *q)
{ {
q1=q1->next; int val;
count++; queue *q1,*prev;
} q1=q;
return count; while(q1->next!=NULL)
} {
prev=q1;
q1=q1->next;
}
val=q1->val;
int peek (queue *q)
prev->next=NULL;
{
free(q1);
queue *q1;
return (val);
q1=q;
}
while(q1->next!=NULL)
q1=q1->next;
return (q1->val);
}
PROBLEM WITH ARRAY
Autumn 2016 Autumn 2016

IMPLEMENTATION
42

• The size of the queue depends on the number and order of enqueue and
dequeue.
• It may be situation where memory is available but enqueue is not possible.

ENQUEUE DEQUEUE
Effective queuing storage area of array gets reduced.
0 N

front
front rearrear

Use of circular array indexing

APPLICATIONS OF QUEUES
CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

43
• Direct applications:-
• Waiting lists
• Access to shared resources (e.g., printer)
• Multiprogramming

• Indirect applications:-
• Auxiliary data structure for algorithms
• Component of other data structures
 CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

44 Any question?

You may post your question(s) at the “Discussion

Forum” maintained in the course Web page.
 CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

Problems
45 to ponder…
 CS 11001 : Programming and Data Structures Lecture #00: © DSamanta

Problems
46 for practice…