Please make sure you adhere to the policies on academic honesty.

Please see the general programming webpage for details about the programming environment for this course, and specifically for directions in how to submit your programming assignment electronically.

The files you need for this assignment can be downloaded here.

Contents:

Overview

((((3+1)x3)/((9-5)+2)) - ((3 x (7-4))+6))

Expression Format

Parsers for languages such as Java must certainly be able to perform such a task. Arithmetic expression appear in source code and must be evaluated in turn. In fact, they deal with a variety of complications, as they allow unary operators (such as "-3"), and operators which take more than two (such as "4+8+2+12"). Furthermore, they enforce a prescribed precedence for operators in the case where the user does not properly parenthesize an expression (imagine "5 - 3 x 4 + 10").

We will consider a simple version of the problem by using only binary operators and by assuming strict parenthesization in expressions. In particular we will make the following recursive definition for a well-formed expression:

• A string representing an integer is a well-formed expression (e.g. "5")

• If expr1 is well-formed, expr2 is well-formed, and op is a binary operator ('+', '-', 'x' or '/'), then the string: "(expr1 op expr2)" is a well-formed expression.

This simple recursive definition allows us to represent arbitrarily complex arithmetic expression (and understanding this recursion will allow you to write a relative simple solution to this assignment!)

You may assume that your routine will be given WELL FORMED expressions. You do not need to be concerned with how to gracefully handle improperly formed expressions.

Examples

Examples of well-formed expressions include (one per line):

13
(5 - 8)
(3 x (4/2))
((((3+1)x3)/((9-5)+2))-((3x(7-4))+6))

Your task

You are to complete the routines defined in file Arithmetic.java:

• BinaryTree parse(String[ ] token)
  This is the routine which takes an expression and builds a tree which represents the expression. For your convenience, rather than give you one long string, our drivers will have already broken up the expression into an array of individual token strings. Each token will either be a string which represents a positive integer, or will be a string from the set { "(", ")", "+", "-", "x", "/" }. The length of the array will be equal to the number of tokens.

  Your routine should take this set of tokens, and generate a valid BinaryTree representing the original expression. In particular, every internal node should contain an element which is the token representing an operator. Every external node should contain a token which represents an integer. (The parentheses from the original expression do not explicitly appear in the tree, rather they provide the context for the expression.)

  Please think about this task, and work on some examples, before you write any code. It is possible to implement this routine directly, and without recursion, but doing so may quickly become quite complicated. It is also possible to write a relatively simple recursive program which works perfectly.

• int evaluate(BinaryTree T)
  This routine should be much more straightforward. In fact, pseudo-code for the routine is given in Code Fragment 6.18 of the text. Note: because we are dealing with integer operands, we will interpret the division operator '/' as the integer division. So 5/2 = 2, and 4/7 = 0. This is consistent with Java's behavior if you are using int values throughout an expression.

  ---

  Drivers

  We will provide you with two drivers for this program.

  • ExpressionDriver - this is a simple text based driver. If entering input from the keyboard, you should enter a well-formed expression on a single line and press return. The driver will immediately break the expression into tokens, and call your routines. You may continue by typing another expression, again on a single line. To exit the program, enter "Q" and hit return.

    As usual, if you prefer to type your input into a file for testing, you may give a filename to the driver as a single runtime argument.

    Note: this driver does not check to make sure expressions are well-formed. We simply guarantee that we will not give poorly formed expressions while grading.

  • ExpressionApplet - this is a more fun way to test your program, as it draws the tree which you have built on the screen.

  ---

  Files you will need

  The files you need for this assignment can be downloaded here.

  ---

  Files to Submit

  You should submit:
  • Arithmetic.java
  • readme - a brief summary of your program, and any further comments you wish to make to the grader. If you do the extra credit, please make this clear.

  If you define any additional classes, please submit the additional source code.

  ---

  Efficiency

  What we care most about in this program is that you get it working correctly. Some may be interested in thinking a bit about the efficiency of their routines. A straightforward recursive implementation of parse may lead to a worst case running time of , where n is the number of tokens in the expression. Though not required, we will point out that it is possible to implement parse to run in O(n) worst-case. This can be done using a non-recursive implementation, and it can even be done using a recursive implementation, though it requires a good deal of thought into how to precisely define the recursion. Even the extra credit can be done in O(n) time with care.

  ---

  BinaryTree interface

  You will not be writing any low-level code for maintaining the tree. The book has already done this for you, and we will provide you with such an implementation. Instead, you will need to use the interface as defined in BinaryTree.java, which itself is based on the Position interface. Our implementation includes all of the Tree methods from Chapter 6.1.2, as well as the specialized BinaryTree methods of Chapter 6.3.1. Since you will need not only to inspect a tree, but to modify it as well, our implementation includes the following methods for a given tree T:

  • T.expandExternal(Position v): Takes an external position v of T, and converts it to an internal node with two newly created external children.

  • T.replaceExternal(Position v, BinaryTree T2): Takes an external position v of T, as well as a second tree T2, and it modifies T by replacing v with a copy of tree T2 as a subtree (the tree T2 might be destroyed by the process).

  • T.removeAboveExternal(Position w): Takes an external position w of T, and deletes w and the parent of w from the tree, promoting the sibling of w into the parents place (see Figure 6.13).

  Finally, we note that the constructor for our implementation:

  BinaryTree T = new LinkedBinaryTree();

  generates a new tree with a single external node which is the root. The element stored at the root will be initialized to null (though you will certainly want to change this at some point).

  ---

  Recursion on BinaryTree's

  One of the beauties of binary trees are that they lead very nicely to the use of recursion. A subtree of a binary tree appears very much to be its own tree.

  In terms of implemenation however, there is one catch. If you call a method such as T.leftChild(v) for a given tree T and position v, it does not actually return to you an object of class BinaryTree; it returns to you a Position within the original tree T. If you look carefully at the many code examples in Chapter 6 of the text, they base their recursion on the concept of a subtree.

  The recursive procedures generally take two parameters, a reference to the full tree and a particular position v. Together, these parameters are used to identify the subtree of T rooted at v. Now recursion can proceed, for instance by making a call with T and T.leftChild(v) as parameters.

  The last detail is that you will often want to use recursion for a public method which takes only a full BinaryTree as a parameter. For example, in this assignment, we have asked for a routine evaluate(BinaryTree T). The recursive pseudo-code of Code Fragment 6.18 of the text is based on the two parameter recursion. The solution is to have the public method serve as a wrapper for the private recursive procedure. Since the public method involves the full tree, you can simply translate this to start the recursive function on the subtree of T rooted at T.root().

  ---

  Useful String methods

  Please keep in mind that the way to test strings for equality is to use the equals() method provided. An example of correct syntax reads,

    if (token[5].equals("+")) {

  In the evaluation routine, you will need to convert the tokens which represent integers into actual int values which you can use. Assuming that you have a Position which represents a leaf of the tree, you can get the value by,

  Position p;  \\ assume this refers to a leaf of the tree.
  int val;
  try {
    val = Integer.parseInt((String) p.element());
  } catch (NumberFormatException e) {
    System.out.println("Unexpected NumberFormatException when parsing "
                        +((String) p.element));
  }

  Although we promise that we will only test your program with well-formed expressions, Java will insist that you catch such a possible exception.

  ---

  Extra Credit (1 point) - generalized expressions

  Implement a routine extraParse(String[ ] token) which handles expressions which are not necessarily fully parenthesized. Note that this is a separate routine, so that we can still grade your original parse routine without fear that your attempt at extra credit caused your original working program to misbehave.

  We define a more general grammer for expression as follows:

  • A string representing an integer is a general expression (e.g. "5")

  • If expr1 is a general expression, then the string: "(expr1)" is also a general expression.

  • If expr1 and expr2 are both general expressions, and op is a binary operator ("+", "-", "x" or "/"), then the string: "expr1 op expr2" is a general expression.

  If you compare this definition to the original, you will notice that it includes all original well-formed expression and many more. Examples of such general expressions include:

  1+2+3+4
  (5)+7
  5-3x4+10
  5-3x(4+10)

  In parsing general expression, you must follow Java's rules for precedence of operators, namely that:

  • Operators "x" and "/" take precedence over operators "+" and "-".

  • Operators with equivalent precedence are evaluated from left to right.

  Thus, the expression "5-3x4+10" is equivalent to "((5-(3x4))+10)", yet the expression "5-3x(4+10)" should be equivalent to "(5-(3x(4+10)))".

  Both drivers will allow you to test the extraParse routine. Using the applet, there is an appropriately labeled button for this routine. With the text-based driver, it can only be done in tandem with reading input from a file. The filename is to be given as the first argument, and a second argument "e" alerts the driver to use the extra credit routine rather than the standard parse. Using JDK,
  java ExpressionDriver inputfile e
  would test the extraParse routine using the inputfile.

  We will award 1 extra point for this task, though we are not in any way implying that this is a minor feat to accomplish. Please make sure that the readme file announces your success.

  ---

  Last modified: 15 November 2002

  ---