CMPS 223 - Homework 5

Homework 5 - Binary Search Trees

Due: Tuesday May 17, 2011 at 5:00pm

The purpose of this assignment is to implement and manipulate binary search trees using linked nodes.

As with the other linked data structures, you will need two structures to implement a binary search tree: one for the tree node and one for the tree. Your tree node structure will contain member variables for the element to store ("data"), the pointer to the right subtree ("right") and the pointer to the left subtree ("left"). The binary search tree structure will contain a member variable for the root node of the tree ("root").

You will implement the following functions for your binary search tree:

void initTree(BST *) - Initialize the root to NULL.
void deallocate(BST *) - Perform a post-order traversal on the tree, which will completely delete all nodes in the left and right subtrees before deleting the root node. Use the helper function deallocateSubtree to accomplish this.
void deallocateSubtree(TreeNode *) - A helper function for deallocation. It is passed a pointer to the current subtree root node. This will recursively call itself to completely deallocate the left and right subtrees before deallocating the current subtree root.
bool insert(BST *, LISTELEM) - Insert the given value into the tree. If the root is currently NULL, allocate a new node for the root and insert the given value there. Otherwise, use the helper function insertSubtree to insert the given value while preserving the BST property. The function should return false if allocation fails or if the given value is already in the tree. It may need to relay the return value from the helper function to accomplish this.
bool insertSubtree(TreeNode *, LISTELEM) - This function is given a pointer to the subtree root and the value to insert. It will see if the value belongs in the left or right subtree. If the correct subtree is currently NULL, allocate a new node and insert it there. Otherwise, recursively call insertSubtree on that subtree. This function will return false if the allocation fails or if the value is already in the tree. Otherwise, it will return true. It will need to return the value of its recursive calls to accomplish this.
TreeNode *search(BST *, LISTELEM) - Search the tree for the value. Return a pointer to the node where the value was found or NULL if the value was not found (or the tree is empty). This is primarily a wrapper around the recursive function searchSubtree.
TreeNode *searchSubtree(TreeNode *, LISTELEM) - Perform the BST search on the given subtree root node. Use recursion to traverse the proper search path for the given value. Return the address of the node containing the value if it is found. Return NULL if subtree root is NULL or you traverse the entire path without finding a match.
void inorderPrint(BST *) - Perform an in-order printing of the tree. This will print all of the tree's values in sorted order. This function is primarily a wrapper around the helper function inorderSubtree.
void inorderSubtree(TreeNode *) - Perform an in-order printing by recursively calling inorderSubtree on the left subtree, then printing the data in the current node, then recursively calling inorderSubtree on the right subtree.
bool remove(BST *, LISTELEM) - Delete the given value from the tree if it is in the tree. Call search to see if the value is in the tree and return false if it is not. Once you have found the node containing the value, perform a second search for the node containing the next in-order value in the tree (the replacement value) and perform the deletion procedure. Return true when the deletion works. Note that you will need to do an iterative search for the replacement value so you can update its parent node accordingly.

Your main function will implement the following menu:

             Binary Search Tree Menu
  ===============================================
  1. Read values from a file to insert into tree
  2. Search the tree for a value
  3. Delete a value from the tree
  4. Print the values of the tree in sorted order

  0. Exit
  ===============================================

Be sure to call initTree before entering the menu loop and to call deallocate after exiting the menu loop. Points will be deducted if this is not done. Also be sure to use robust input for the menu options (e.g. clear the input stream if a user types a letter instead of one of the option integers).

Option 1 should prompt the user for an input file, read the input file and insert the values one at a time into the tree in the order given in the input file. If the file open fails, return to the menu. Don't forget to close the file after reading the input. One of the following input files will be used to test your code (you can also generate additional input files using the code file_gen.cpp):

hw5_input1 contains 25 integers.
hw5_input2 contains 50 integers.
hw5_input3 contains 100 integers.

Option 2 should prompt the user for a value, even if the tree is empty, to be sure that the function properly handles all cases. It will call search and store the resulting pointer. If the result is NULL, print out an error message about the item not being found (there should be NO such error message in your tree functions). Otherwise say that the item was found in the tree.

Option 3 should likewise always prompt the user for a value, even if the tree is empty, to be sure that the function properly handles all cases. It will call remove and see if remove returns true or false. If remove returns true, say that the value was deleted. Otherwise, say that the value was not found in the tree.

Option 4 will call inorderPrint, even if the tree is empty. This will print all the values in sorted order.

Email the completed source code to me.