Dr. Nazli Mollah
Data Structures: CSCI 362 – Stack ImplementationData Structures: CSCI 362 – Stack Implementation
lecture notes adapted fromData Structures with C++ using STL
Stack ImplementationStack Implementation
Stacks can be Implemented by:
Static ArraysFixed size
Good is size is known
Dynamic ArraysFlexible
Good if insertion and deletion is infrequent
Linked ListsFlexibleDynamic
Dr. Nazli Mollah
Data Structures: CSCI 362 – Stack ImplementationData Structures: CSCI 362 – Stack Implementation
lecture notes adapted fromData Structures with C++ using STL
Stack ImplementationStack Implementation
All versions have common operations (STL)
Void pop()// pop & removes the top item from the stack
Void push(const T & item)//pushes/ adds items on top of stack
Bool empty() const//returns true if stack is empty
Int size() const//returns number of items in stack
T&top()//returns a reference to the top of the stack without removing it
Const T& top() const// constant version of top
Destructors (for linked list and dynamic arrays)
Dr. Nazli Mollah
Data Structures: CSCI 362 – Stack ImplementationData Structures: CSCI 362 – Stack Implementation
lecture notes adapted fromData Structures with C++ using STL
Stack ErrorsStack Errors
Stack underflow//condition resulting from trying to access an item from an empty stack
Stack overflow//condition resulting from trying to push/ add an item onto a full stack
Dr. Nazli Mollah
Data Structures: CSCI 362 – Stack ImplementationData Structures: CSCI 362 – Stack Implementation
lecture notes adapted fromData Structures with C++ using STL
Postfix Expression - IntroductionPostfix Expression - Introduction
aka Reverse Polish Notation (RPN) after Polish mathematician Jan Lukasiewwicz Calculators use this format extensively
Postfix Format: an operator is entered in the expression as soon as 2 operands are available
e.g. 8 + (4* 12 + 5%2) / 3 contains: Operands: (8, 4, 12, 5, 2, 3) Operators: (+, *, %, /) Parenthesis: subexpressions
Dr. Nazli Mollah
Data Structures: CSCI 362 – Stack ImplementationData Structures: CSCI 362 – Stack Implementation
lecture notes adapted fromData Structures with C++ using STL
Infix vs. PostfixInfix vs. Postfix
Infix a + b * c
(a + b) * c
(a*b+c)/d + e
a*b – c/d
a*b*c*d*e*f
(b*b-4*a*c)/(2*a)
Postfix abc*+
ab+c*
ab*c+d/e+
ab*cd/-
ab*c*d*e*f*
bb*4a*c*-2a*/
Dr. Nazli Mollah
Data Structures: CSCI 362 – Stack ImplementationData Structures: CSCI 362 – Stack Implementation
lecture notes adapted fromData Structures with C++ using STL
Postfix Evaluation AlgorithmPostfix Evaluation Algorithm
Scan each term of the expression from left to right
Use a single stack to hold the operands
If a term is an operand, push it onto the stack
If a term is a binary operator, evaluate its result because its 2 operands are already on stack on the 2 top positions
Pop the stack to retrieve the operands
Evaluate the expression
Push the result back onto the stack
Dr. Nazli Mollah
Data Structures: CSCI 362 – Stack ImplementationData Structures: CSCI 362 – Stack Implementation
lecture notes adapted fromData Structures with C++ using STL
Postfix Evaluation AlgorithmPostfix Evaluation Algorithm
Consider the expression 4 3 5 *+ Its postfix requires 7 steps
4 19444
3 3
5
15
Push 4
Step 1
• Read * operator• Pop first 2 operands on stack• Compute 5*3 = 15
Push 3 Push 5 Push 15 Push 19
• Read + operator• Pop first 2 operands on stack• Compute 15+4 = 19
Step 6Step 5Step 4Step 2 Step 3 Step 7
Dr. Nazli Mollah
Data Structures: CSCI 362 – Stack ImplementationData Structures: CSCI 362 – Stack Implementation
lecture notes adapted fromData Structures with C++ using STL
Postfix - Detecting ErrorsPostfix - Detecting Errors
Errors can occur during the evaluation of a postfix expression At each step in the algorithm, the state of the stack allows us to identify
when an error occurs and the cause of the error
e.g. 38+*9 ERROR Too many successive operators * is missing a second operand
e.g. 98+7 ERROR Too many operands What to do with 7?
Dr. Nazli Mollah
Data Structures: CSCI 362 – Stack ImplementationData Structures: CSCI 362 – Stack Implementation
lecture notes adapted fromData Structures with C++ using STL
Designing Postfix Evaluation Class for Implementation d_rpn.hDesigning Postfix Evaluation Class for Implementation d_rpn.h
Class postfixEval
{
public:
postfix Eval();
// default constructor
// postfix expression is a NULL string
string getPostfixExp() const;
// access member function which enables a programmer to retrieve the current expression
void setPostfixExp(const string& postfixExp);
// operation which takes a string argument containing the postfix expression
int evalaute();
// key member function which attempts to compute the value of the postfix expression
// if successful, it returns the value of the expression
// if the expression contains an error, the function throws the expressionError exception
Dr. Nazli Mollah
Data Structures: CSCI 362 – Stack ImplementationData Structures: CSCI 362 – Stack Implementation
lecture notes adapted fromData Structures with C++ using STL
Designing Postfix Evaluation Class for Implementation d_rpn.hDesigning Postfix Evaluation Class for Implementation d_rpn.h
private:String postfixExpression;
// the characters in the string include operands, operators, and white space characters// such as blanks, tabs//These are scanned by the evaluate() function
Stack<int> operandStack;// stack pf operands stored during operations and used by evaluate() function
void getOperands (int& left, int& right);// pops the left and right operands from stack// precondition: checks that the stack is not empty and has at least 2 entries before each pop operation// an empty stack prior to pop() operations indicates that there are too many operators and the// function throws an expressionError exception
int compute (int left, int right, char op) const;// evalautes an operations// pushes result onto a stack// for (/) and remainder (%) operators, compute() checks the RH operator to see if it is 0// If it is 0, the function throws an exressionError exception with the message “Divide by 0”// for the exponentail operator (^), compute() checks for (0,0) and throws an ExpressionError exception
Bool isOPerator (char ch) const;// determines whether a character is one of the valid operators (+, -, *, /, %, ^)
};
Utility functions to implement algorithm
Top Related