Transcript Lecture 12
DCO20105 Data structures and algorithms
Lecture
12:
Stack and Expression Evaluation
Stack
• basic operations of a stack
• its implementation using a vector
• applications of stack
Expression Evaluation
• Infix, Prefix, and Postfix expressions
• Implementation of evaluating a postfix expression
-- By Rossella Lau
Rossella Lau
Lecture 12, DCO20105, Semester A,2005-6
Stack
Stack
is an ordered list of items, ordered in the input
sequence
Basically,
items
are inserted and deleted at one end, called the top of the stack
are last in first out (LIFO)
An
example:
The original
Add an item
Take an item
C
C
B
A
Rossella Lau
Add an item
B
A
D
B
A
E
D
B
A
Lecture 12, DCO20105, Semester A,2005-6
Operations of a stack
Basic:
push() – to add an item
pop() – to remove an item
Assistance:
size() – returns the number of items in a stack
empty() – to check if a stack is empty
top() – returns the first element of a stack;
note that in a queue, it is called front()
Rossella Lau
Lecture 12, DCO20105, Semester A,2005-6
Exercises
Ford:
Rossella Lau
7: 13,14; 8:11
Lecture 12, DCO20105, Semester A,2005-6
Implementation of a stack using a vector
// Stack.h
template<class T>
class Stack {
private:
vector<T> stack;
public:
void push(T const & item) {stack.push_back(item);}
T & pop() {T t(top()); stack.pop_back();
return t;}
size_t size()
const { return stack.size();}
bool empty()
const { return stack.empty();}
T const & top() const { return stack.back();}
};
Rossella Lau
Lecture 12, DCO20105, Semester A,2005-6
Applications of stack
Nested parentheses check
Expression evaluation
The underlying structure for recursion
Function calls (and its associated variables), e.g., :
init
init
push
pop
check
check
check
check
main
main
main
main
Rossella Lau
push
…
Lecture 12, DCO20105, Semester A,2005-6
A stack application: nested parentheses check
Consider the parentheses in mathematical expressions
1. Equal number of right and left parentheses
2. Every right parenthesis is preceded by a matching parenthesis
Wrong expressions:
((A+B)
violate condition 1
)A+B(-C
violate condition 2
Solution:
nesting depth
parenthesis count
Rossella Lau
Lecture 12, DCO20105, Semester A,2005-6
Use of nesting depth and parenthesis count
Nesting depth:
left parenthesis: open a scope
right parenthesis: close a scope
nesting depth at a particular point is the number of scopes that have been opened
but not closed
Parenthesis count:
at a particular point as the number of left parentheses minus the number of right
parentheses
if the count is not negative, it is the nesting depth
Check parentheses use by checking if parenthesis count:
is greater than or equal to 0 at any point
is equal to 0 at the end of the expression
of course, checking should include the parenthesis type: {}, [],()
Rossella Lau
Lecture 12, DCO20105, Semester A,2005-6
Use of a stack to check
For each
left parenthesis, do a push
For each
right parenthesis, do a pop and make sure the item
popped is equal to the right parenthesis (same type)
If
the stack is empty when doing a pop ERROR
If
the stack is not empty when the expression ends ERROR
Examples
of checking invalid expressions:
((A+B)
[(A+B])
)A+B(-C
(
(
(
Rossella Lau
(
(
!empty(s)
Cannot pop
(
[
(
[
Type mismatch
Lecture 12, DCO20105, Semester A,2005-6
Algorithm to check pairs of parentheses
bool check(string expression){
valid = true
stack<char> brackets
while (expression not end){
read a symbol (symb)
if symb is a left bracket
brackets.push(symb)
if symb is a right bracket{
if brackets.empty()
valid=false
if brackets.front()
not match symb
valid = false
brackets.pop()
} }
if !brackets.empty()
valid = false
return valid}
Rossella Lau
{x+(y-[a+b])*c-(d+e)}/(h-(j-(k-[l-n])))
[
[
(
{
(
{
{x+(y-[
{…a+b])
(
(
{
{
{…*c-(
{…d+e)
[
{
{…}
[
(
(
(
…/(h-(j-(k-[
(
(
(
…l-n])))
Lecture 12, DCO20105, Semester A,2005-6
Expression evaluation
An
expression is a series of operators and operands
Operators:
+, -, *, /, %, $ (exponentiation)
Operands:
the values going to be operated
Three representations of an expression:
Infix:
The usual form, operator is between operands
Prefix:
the operator is in front of the operand(s)
Postfix:
the operand(s) is(are) in front of the operator
Rossella Lau
Lecture 12, DCO20105, Semester A,2005-6
Examples of Prefix Expressions
Infix
Prefix
A+B
+AB
A+B-C
(A+B)*(C-D)
A$B*C-D+E/F/(G+H)
((A+B)*C-(D-E))$(F+G)
A-B/(C*D$E)
Rossella Lau
-+ABC
*+AB-CD
+-*$ABCD//EF+GH
$-*+ABC-DE+FG
-A/B*C$DE
Lecture 12, DCO20105, Semester A,2005-6
Examples of Postfix Expressions
Infix
Postfix
A+B
AB+
A+B-C
(A+B)*(C-D)
A$B*C-D+E/F/(G+H)
((A+B)*C-(D-E))$(F+G)
A-B/(C*D$E)
Rossella Lau
AB+CAB+CD-*
AB$C*D-EF/GH+/+
AB+C*DE--FG+$
ABCDE$*/-
Lecture 12, DCO20105, Semester A,2005-6
Evaluating a postfix expression
The
advantage is no
parentheses, i.e., less
complication
Since
the operator
comes later, operands
can be pushed to the
stack first and once an
operator is
encountered, the
operands are popped
for the calculation
The
algorithm (one
digit operands) :
Rossella Lau
/* for one digit operands and no
space in the expression */
int eval(string const & expr) {
Stack<int> operands;
for (size_t i=0; i<expr.size();i++){
char c = expr[i];
if (isdigit(c)) //operand
operands.push((double)(c-'0');
else { // operator
int operand2=operands.pop();
int operand1=operands.pop();
operands.push(cal (c, operand1,
operand2));
} }
return operands.top();
}
Lecture 12, DCO20105, Semester A,2005-6
The algorithm for more than one digit
double eval(string const & expr) {
Stack<double> operands;
char c, number[MAX];
size_t i, j=0;
double num;
for (i=0; i<expr.size(); i++) {
c = expr[i];
if (isdigit(c) || c=='.')
number[j++]=c;
else { // a token is parsed
if (j)
...... // convert number to num
operands.push(num);
if (c != ' ') { // operand
...... // pop, cal, and push
}} }
return operands.top();
}
Rossella Lau
......//convert number to num
number[j]='\0'; j=0;
num = atof(number);
...... // pop, cal, and push
double operand2 =
operands.pop();
double operand1 =
operands.pop();
operands.push(cal(c,
operand1,
operand2));
Lecture 12, DCO20105, Semester A,2005-6
cal(char, double, double)
double cal(char oper, double op1,double op2) {
switch (oper) { // “operator” is a key word
case '+': return op1 + op2;
case '-': return op1 - op2;
case '*': return op1 * op2;
case '/': return op1 / op2;
case '$': return pow(op1,op2);
default: // should not happen
exit(EXIT_FAILURE);
}
}
Rossella Lau
Lecture 12, DCO20105, Semester A,2005-6
An example of postfix expression evaluation
4
57+*
scan 457: push(4), push(5), push(7)
scan +: op2=7, pop(), op1=5, pop(), push(op1+op2)
scan *: op2=12, pop(), op1=4, pop(), push(op1*op2)
expression end ==> return 48!
Rossella Lau
Lecture 12, DCO20105, Semester A,2005-6
Summary
A stack
It
is one of the most basic data structures in the study.
only has one end for insert and delete.
An
item in a stack is LIFO while it is FIFO in a queue
Stack
One
An
is used in many hidden areas of computer systems
popular important application is expression evaluation
expression can be in three forms: infix, prefix, and postfix
It
is common to evaluate an expression by using a postfix
format
Rossella Lau
Lecture 12, DCO20105, Semester A,2005-6
Reference
Ford:
7
Example
programs: evaluateIntExpression.cpp,
evaluateDoubleExpression.cpp
STL online
references
http://www.sgi.com/tech/stl
http://www.cppreference.com/
-- END -Rossella Lau
Lecture 12, DCO20105, Semester A,2005-6