Assignment 1
Due date: Wednesday May 19 , 2010
Late assignments will be penalized by 15% points per day, and will not be accepted after 3 days.
1. Hand In
Each student is required to do this assignment individually and email your programs (sources and
executable to your GA (Yifeng Li at li11112c@uwindsor.ca). Clearly state the followings in the
subject of your email (and in the email too):
Full Name, Student Number, Assignment Number, Course Number
Please email all of your assignment only once.
Marking Scheme
10 points for Good Programming (comments, simplicity, easy to read, …).
Make sure that your source codes will compile and that the executables will run. The GA
will compile your sources. This to make sure that your executables are really yours.
20 points for Question 1
10 points for question 2
20 points for Question 3
10 points for question 4
2. Question 1
Implement an array-based abstract data type ‘stack’ specified in class and do the following
Write a procedure called read_and_evaluate_expression that reads in and evaluates a postfix
expression (defined below) and writes out its value.
Your procedure must follow the algorithm sketched below, and it must use your implementation
of abstract `stacks'. But the procedure should not depend on the details of your particular
implementation -the procedure should depend only on the specification of abstract `stacks' and
therefore should work with any implementation of the specification (The TAs might check this
by using their own stack implementation instead of yours).
The main program is a loop that calls read_and_evaluate_expression repeatedly. After evaluating
an expression, it should ask the user if he wants to quit (YES) or not (NO, to continue to evaluate a
new expression).
3. Postfix Expressions
A postfix expression has the form X1 X2 X3 ... Xn where each of the Xi is either a single digit
(0...9) or one of the following binary operators: +, -, *, / (the operator / means integer division).
We adopt the convention that a postfix expression fits entirely on 1 line of input. In other
words, the newline character, written '\n' in Java, indicates the end of the expression.
Should you find it convenient, you may also assume that X1 is the first character on the line,
and that each Xi is separated from the next by exactly one space (i.e. ' ' in Java).
The expression is postfix because an operator is written after its two operands. For example, the
normal (infix) expression 2+3 would be written 2 3 + in postfix. Postfix has the advantage that
parentheses are never needed. In infix, one expression (e.g. 2+3*4) can have several possible
meanings (e.g. (2+3) *4 and 2+(3*4)) and parentheses (or precedence conventions) are needed in
order to distinguish among the possible meanings. In postfix, each expression has a unique
meaning.
For example, (2+3) *4 would be 2 3 + 4 * in postfix, whereas 2+(3*4) would be 2 3 4 * +.
4. Algorithm for evaluating postfix expressions (Sketch)
There is one stack for holding operands, called NumStk, which is initially empty.
● Read in the next digit or operator.
● Whenever you read a digit, push it onto the NumStk stack.
● When you read in an operator - let's call it op - since it is a binary operator, it requires two
arguments:
❍ Remove the first two numbers from NumStk; call the first one removed R and the
second one L.
❍ Evaluate L op R and push the result onto NumStk.
● Ignore any blank space. If in fact we find a newline character, then we have reached the end of
the expression. It should now be fully evaluated, and the resulting value must be on top of
NumStk. We write it out and return.
Example: input line is 2 3 4 * + 5
● read '2', push it onto NumStk.
● read following space.
● read '3', push it onto NumStk.
● read following space.
● read '4', push it onto NumStk.
● read following space.
● read '*'. Pop NumStk: R=4. Pop NumStk: L=3. L op R = 3 * 4 evaluates to 12. Push 12 onto
NumStk.
● read following space.
● read '+'. Pop NumStk: R=12. Pop NumStk: L=2. L op R = 2 + 12 evaluates to 14. Push 14 onto
NumStk.
● read following space.
● read '5'. Push it onto NumStk.
● read following space.
● read '-'. Pop NumStk: R=5. Pop NumStk: L=14. L op R = 14 - 5 evaluates to 9. Push 9 onto
NumStk.
● read newline character. Pop NumStk to get final answer 9 and write it out.
4. Question 2
Analyze your read_and_evaluate_expression algorithm and give its running time in Big-Oh
notation.
The following next questions will be part of assignment 2. Please do not include them in
assignment 1.
5. Question 3
Repeat question 1 using a linked list implementation of the abstract data ‘stack’.
6. Question 4
Analyze your algorithm in question 3 and give the Big-Oh notation.