Scribd
Upload
54 views

Problem Solving With ADT - Stacks

This document discusses using stacks to solve problems involving balanced braces and evaluating postfix expressions. It defines a stack as a limited access data structure that follows LIFO order. To check for balanced braces in a string, the pseudocode uses a stack to add opening braces and remove matching closing braces. To evaluate a postfix expression, the pseudocode uses a stack to push operands and pop operands to perform binary operations, pushing the results back to the stack.

Uploaded by

lordjebus2000
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
54 views

Problem Solving With ADT - Stacks

This document discusses using stacks to solve problems involving balanced braces and evaluating postfix expressions. It defines a stack as a limited access data structure that follows LIFO order. To check for balanced braces in a string, the pseudocode uses a stack to add opening braces and remove matching closing braces. To evaluate a postfix expression, the pseudocode uses a stack to push operands and pop operands to perform binary operations, pushing the results back to the stack.

Uploaded by

lordjebus2000
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 14

Problem Solving with ADT

--Stacks
Definition of Stack
 ADT level Abstract Data Type
• A stack is an ordered group
of homogeneous items, in
which the removal and
addition of stack items can
take place only at the top
of the stack
• A limited access data
structure
 A stack is a LIFO: last
item in, first one out
Checking for Balanced Braces
Balanced: a+{c*{a+b}*d}+{d+e}
Unbalanced: {asdf{df}{dfa{df}
Pseudocode

while (not end of string){


if (ch is ‘{‘)
add ch to ADT Add new item
else if (ch is ‘}’){
if (ADT is empty)
return unbalanced;
remove from ADT the item
Remove item
added most recently
}
}
if (ADT is empty)
return balanced; Check emptiness
return unbalanced;
Stack ADT
char stack[Size]; //characters
while (not-end-of string){
if (ch is ‘{‘)
push(stack,ch);
else if (ch is ‘}’){
if( stackempty()){
destroystack();
return unbalanced;
}
item = pop(stack);
}
}end while
if (stackempty())
return balanced;
destroyStack();
return unbalanced;
5
A Stack -- Graphic
Array-Based Implementation

char/int stack[size]

bool stackfull();
bool stackempty();
void push(stack, item);
char pop(stack);
char gettopitem(stack);

itemtype stack[MAX];
int tos; //top of stack
};
Push – item on Stack
push (stack, item) item is of type char
if (not stackfull()) stack must not be full
stack[tos] = item add item
tos = tos + 1 increment top-of-stack
else
write(“Stack is full, can’t add item”)
end if
end push
Pop – item of Stack
char pop (stack ) popped item is of type char
if (not stackempty() ) stack must not be empty
tos = tos – 1 decrement the top-of-stack
item = stack[tos] item on top of stack
return item
else
write(“Stack is empty, can’t pop item”)
end if
end pop
Compare Three Implementations
Will do this later.

 Array v.s. Linked List


• Fixed size v.s.
dynamic size
 Linked List v.s. ADT
List
• Efficiency v.s.
Simplicity
Application: Algebraic Expressions
 Infix expressions
• Every binary operator appears between its
operands: a+b*c, (a+b)*c
 Prefix expressions
• Operator appears before its operands:
+a*bc, *+abc
 Postfix expressions
• Operator appears after its operands:
abc*+, ab+c*
Evaluating Postfix Expressions
Pseudocode (binary operations only)

Stack mystack; declare a stack


for (each token t in the input){
if (t is an operand)
push(mystack,t);
else {
// pop top item of stack
operand2 = pop(mystack);
// pop top item of stack again
operand1 = pop(mystack);
// compute binary operation
result = operand1 t operand2;
push(mystack, result);
}
}
Postfix Evaluation Algorithm
Initialise stack to empty;
while (not end of postfix expression) {
Get next postfix item (char)
if (item is operand)
push(stack, item)
else if (item is binary operator) {
x = pop(stack)
y = pop(stack)
z = y operator x
push(stack, z) }
else if (item is unary operator) {
x = pop(stack)
z = operator(x)
push(stack,z) }
}
result = pop(stack) // single value at end on stack

You might also like