Stack ADT

Stack ADT
1 Mrs.K.Arunasakthi, AP/CSE
21CS202 - STACK ADT
Mrs. K.Arunasakthi
Assistant Professor
Computer Science & Engineering,
Velammal college of Engineering & Technology, Madurai

Stack
2
 Basic principles
 Operation of stack
 Stack using Array
 Stack using Linked List
 Applications of stack
Mrs.K.Arunasakthi, AP/CSE
21CS202 - STACK ADT

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.
21CS202 - STACK ADT

Stack Representation
• Can be implemented by means of Array, Structure, Pointers and
Linked List.
• Stack can either be a fixed size or dynamic.
21CS202 - STACK ADT

5
STACK
push
create
pop
isfull
isempty
21CS202 - STACK ADT

STACK: Last-In-First-Out (LIFO)
• 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 */
6
Assumption: stack contains integer elements!
21CS202 - STACK ADT

Stack using Array
21CS202 - STACK ADT

8
top
top
PUSH
Push using Stack
21CS202 - STACK ADT

9
top
top
POP
Pop using Stack
21CS202 - STACK ADT

• 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.
10
Basic Idea
21CS202 - STACK ADT

Stack Using Array
11
Declaration & Creation of Stack
#define MAX 100
int stack[MAX];
// int stack[100];
int top =-1;
21CS202 - STACK ADT

Pushing an element into stack
12
void push(int st[], int val)
{
if(top == MAX-1)
{
printf("n STACK OVERFLOW");
}
else
{
top++;
st[top] = val;
}
}
 Process of inserting an
element into the stack.
 For inserting an
element Top will be
incremented by 1
 Element should be
pushed on to the top of
the stack.i,e.,
st[top]=val
 Top=Top+1 // Top++
21CS202 - STACK ADT

Popping an element from stack
13
int pop(int st[])
{
int val;
if(top == -1)
{
printf("n STACK UNDERFLOW");
return -1;
}
else
{
val = st[top];
top--;
return val;
}
}
 Pop is the process of
removing the top element
from the stack.
 After removing top should
be decremented by 1
 top=top-1 or top--;
21CS202 - STACK ADT

Checking stack- Full or Empty
14
int isempty(int st[])
{
if(top == -1)
{
printf("n STACK IS EMPTY")
return -1;
}
}
EMPTY
Checking that whether the
given stack is empty
FULL
Checking that whether the given
stack is empty
int isfull(int st[])
{
if (top == MAX-1)
printf(“STACK IS FULL”);
else
return (0);
}
21CS202 - STACK ADT

Display the Stack and PEEK
15
void display(int st[])
{
int i;
if(top == -1)
printf("n STACK IS EMPTY");
else
{
for(i=top;i>=0;i--)
printf("n %d",st[i]);
printf("n"); // Added for
formatting purposes
}
}
DISPLAY
Process of displaying all the
elements in the stack.
FULL
Displaying the Top element of
the Stack.
int peek(int st[])
{
if(top == -1)
{
printf("n STACK IS EMPTY");
return -1;
}
else
return (st[top]);
}
21CS202 - STACK ADT

Stack using Linked List
21CS202 - STACK ADT

17
top
PUSH OPERATION
Push using Linked List
21CS202 - STACK ADT

18
top
POP OPERATION
Pop using Linked List
21CS202 - STACK ADT

Declaration – Stack using Linked List
19
struct lifo
{
int value;
struct lifo *next;
};
typedef struct lifo
stack;
stack *top;
21CS202 - STACK ADT

Stack Creation
20
void create (stack **top)
{
*top = NULL;
/* top points to NULL,
indicating empty
stack */
}
LINKED LIST
21CS202 - STACK ADT

Pushing an element into stack
21
void push (stack **top, int element)
{
stack *new;
new = (stack *)malloc (sizeof(stack));
if (new == NULL)
{
printf (“n Stack is full”);
exit(-1);
}
new->value = element;
new->next = *top;
*top = new;
}
LINKED LIST
21CS202 - STACK ADT

Popping an element from stack
22
int pop (stack **top)
{
int t;
stack *p;
if (*top == NULL)
{
printf (“n Stack is empty”);
exit(-1);
}
else
{
t = (*top)->value;
p = *top;
*top = (*top)->next;
free (p);
return t;
}
}
LINKED LIST
21CS202 - STACK ADT

Checking for stack empty
23
LINKED LIST
int isempty (stack *top)
{
if (top == NULL)
return (1);
else
return (0);
}
21CS202 - STACK ADT

Example: A Stack using an Array
24
#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;
}
21CS202 - STACK ADT

Example: A Stack using Linked List
25
#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;
}
21CS202 - STACK ADT

Applications of Stacks
• 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
• Reversing a List, Paranthesis checker, Tower of hanoi
• Indirect applications:
• Auxiliary data structure for algorithms
• Component of other data structures
21CS202 - STACK ADT

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
21CS202 - STACK ADT

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
21CS202 - STACK ADT

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.
21CS202 - STACK ADT

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.)
21CS202 - STACK ADT

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.
21CS202 - STACK ADT

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
21CS202 - STACK ADT

21CS202 - STACK ADT 33

Stack ADT

More Related Content

What's hot (20)

Similar to Stack ADT (20)

Recently uploaded (20)

Stack ADT