Tree Enhancement Program

(Latest Revision: 12/11/2000)
12/11/2000: Added some wording to clarify what a test plan is.

Working With Trees: Extending the Binary Search Tree Class

THE ASSIGNMENT:

Your assignment is to extend the Binary Search Tree ADT by adding the following operations:

   Name          Type                     Purpose

PrintTree       void function    Print a representation of a
                                 binary search tree to the standard
                                 output.
                                 
SimilarTrees    bool function    Determine if two binary search
                                 trees have the same shape. 

LeafCount       int function     Determine the number of leaf
                                 nodes in a binary search tree.

Ancestor        void function    Given the keyValue, print the
                                 ancestors of a node in a binary
                                 search tree.

In other words, you must make additions to BST2.h and BST2.cpp so that bstClass makes the new operations available.

PrintTree:

The function PrintTree must have output like this:

               Y This is a test string
          W This is a test string
               U This is a test string
     T This is a test string
               S This is a test string
          Q This is a test string
               O This is a test string
M This is a test string
               L This is a test string
          J This is a test string
               I This is a test string
     G This is a test string
               F This is a test string
          D This is a test string
               B This is a test string

As you can see, the tree has been printed out "sideways" with indentation used to to put each string into the correct position relative to its "parent". Also, when the tree is rotated 90 degrees clockwise, the keys can be read in order from left to right. Let's discuss how to do this in class. There is a very simple way to implement this operation.

SPECIFICATIONS:

The first part of your assignment is to write the specifications of each operation in the following format:

Operation (parameter list)

Function:
Inputs:
Preconditions:
Outputs:
Postconditions:

Here is an example that that shows how the format looks when applied to a void function called FindNode. Your operations will probably all have simpler postconditions than the ones for FindNode.

void FindNode
  (  keyType   keyValue ,
     ptrType&  nodePtr,
     ptrType&  parentPtr
   );

Function:

Find the node that contains keyValue;

Inputs:

keyValue -- the key value of the tree node to be sought.

Preconditions:

None

Outputs:

nodePtr -- a pointer for the node sought, and parentPtr
parentPtr -- a pointer for the parent of the node sought

Postconditions:

If the search succeeds and the node sought is not the root node:
- then nodePtr points to the node sought, and parentPtr points to the parent of the node sought.
If the search succeeds and the node sought is the root node:
- then nodePtr points to the node sought, and parentPtr is NULL.
If the search does not succeed and the tree is not empty:
- then nodePtr is NULL and parentPtr points to the tree node that would be the parent of the node sought, if that node were in the tree.
If the tree is empty:
- then nodePtr is NULL and parentPtr is NULL.

Once you have specified the operations, you must implement them. Use recursion wherever possible.

TESTING THE OPERATIONS:

You must test each new operation thoroughly to make sure it is correct. To do that you must decide on a set of test inputs for each function. The set of test inputs has to give good data and code coverage. You must write a test plan telling in detail what test inputs you are going to use for each operation. Your grade is determined in part by the completeness of your test plan.

Create a batch test driver program driver.cpp that executes these test cases. The driver must write all output to standard output (the screen).

It's important that the output of driver.cpp be self-explanatory. Just from looking at the screen the user must be able to tell what the inputs to each test are, what the test does, and what the outcome is. For example use "before" and "after" labels, statements, and calls to PrintTree to accomplish this.

Your test driver is allowed to call any of the public operations that are declared in the files BST2.h or Data.h. Of course, your driver may also call any of the operations that you add by making changes to bstClass.

WHAT TO TURN IN:

Before midnight on the first due date, turn in:
- specifications for all the new operations,
- a copy of your test plan, and
- the code for at least 1 of the 4 new operations.
Turn this material in on paper. You must turn in your paper at the start of class time on the due date.
Before midnight on the second due date, turn in:
- your completed copies of BST2.h, BST2.cpp,
- your driver.cpp file, and
- a script showing the outcome of an execution.
You must shar all these materials into a single archive file and send them via e-mail with subject line: "CS2500,prog5.fin".

Note that there are no spaces in the subject lines given. It is important that you do not insert any spaces. My e-mail address is: john@ishi.csustan.edu.

DUE DATES:

For the due dates, see the class schedule.