Binary Search Tree (tree)
CS 162 - Spring 2008

Enter a line of input to insert: 
marauder
Tree after input.
      u
   r
      r
m
         e
      d
         ~
   a
      a

Inorder traversal: aademrru

Enter a line of input to remove:
rummage
Tree after trimming.
   r
d
   a

Inorder traversal: adr

Specification
Your program will obtain two lines of input from the user. Use the first line to create a sorted binary search tree of characters. When the characters are all in the tree, print the tree sideways so that we can see where the nodes are. Also print the characters in sorted order by traversing the tree in inorder fashion with all the characters on one line. Then use the second line of input by deleting the characters in the second line from the tree. When all the characters from the second line have been deleted from the tree, print the remaining characters in the tree as above. Label your output appropriately. Do not put spaces or commas between tree elements when doing an inorder traversal. Note that spaces and tabs are character inputs that will be put into the tree although you don't see them printed. They are allowable input, but beware having them in your test cases because you'll have difficulty seeing them in the sideways tree.

You must use the BTnode<E> class we provide. You must implement the insert and remove methods recursively.

Steps to Start
To create a directory for your tree lab, copy the binarytree directory from the link162 directory. That directory contains the btree package as well as a start to this program in BStree.java. There are some examples that might come in handy. The btree package contains BTnode.java and Btree.java which contain the BTnode<E> class and binary tree methods.

The author discusses the insert and remove methods for binary search trees starting on page 488. His discussion of insert doesn't use recursion although our lectures do. The textbook might be helpful, but it is easier to write these recursively. To get full credit on this assignment, you MUST write them recursively.

 

Binary Search Tree Storage Rules (p. 489 of text plus our header node constraint)

In a binary search tree, the entries of the nodes can be compared with a total order semantics. These two rules are followed for every node n: Every element in n's left subtree is less than or equal to the element in node n. Every element in n's right subtree is greater than the element in node n. The tree has a header node containing null as its element. By the above rules, the tree's contents will be stored in the right subtree of that header node.

Solving the Problem

• Read through all parts of this handout. There are implementation hints at the bottom the page. They'll help.
• Examine what you have and understand problem. Examine the simple version of the program. It compiles and executes cleanly but doesn't seem to do anything. Read the comments. Understand the data representation. Note that the tree has a BTnode<Character> header node containing the null character. Having this header node at the top allows us to add or remove the top node. However, we must skip it when starting any printing.
• Remember iterative enhancement. Enhance the program slowly. Test the newly added feature before moving on to the next part. We've used this approach all semester. You should keep doing it in your remaining courses and whenever you design software.
• Start small with a 2-3 node tree. For a very simple start, in main add a couple of nodes (your initials?) to the tree. Do this by directly creating nodes. Be sure that the nodes meet the storage rules.
• Print tree. For debugging, printing the tree as you build it helps. Modify the print method so that it calls the printSideways and inorder methods of Btree. Do just the printSideways first.
  Those methods take the root of the tree as their first parameter. Remember that the tree has a header node and skip it. Pass in bst.getRight( ) as the root of your tree. Btree.printSideways also needs 0 as its second parameter indicating initial indenting depth. Btree.inorder needs this as its second parameter to use this class's visit method.
• Write visit method. This class implements the BTnode.Visitor interface. That means it provides a visit method that is called every time the inorder method visits a node. You provide that method by writing the code for the visit method. What should happen at every node? The node is a parameter there, so you can use it.
• Execute and test. When you run your program, do you see your tree?
• Read a line of input. Give a prompt and read a single line of input into a String using nextLine( ). Write a loop that iterates through the characters of the String printing them. (You'll change this to insert them in the next step.) Note that if there are spaces ('  '), they will get in your tree. That's okay. All characters other than newline are allowed.
• Insert characters of first input line into tree. Write the insert method to place each character into the binary search tree. The node passed into this method cannot be null. Look ahead before falling off a subtree. Call this method with each character you read in the first line. Your implementation must be recursive.
• Test what you have. Run your program multiple times with different input. There are no JUnit tests.
• Read another line of input. Read another line to remove.
• Remove characters of second input line from tree. Write the remove method. It needs the dataFromDeletedRightmost and replaceChild methods. Write those as well. Call remove with each character of the second line of the input. As part of its work, remove calls the other two methods. See below.
• Check your work. Be sure to properly label all output. Use the print method and small amounts of data to check that you are adding and removing correctly. Remove the intermediate calls to print before submitting. Your final output should have two sideways trees and two inorder traversals as shown in the example. The example is a good test case.

  Your code should be appropriately commented and indented. Remember that each method should have a good one-line comment. What I'm giving you has comments. Be sure your name is at the top after mine. Compile again immediately before submitting your code to be sure that you didn't accidentally type something the compiler doesn't recognize. I will be accepting only the BStree.java file.

Hints for the methods - their implementations must be recursive.
All connections are made from above. Draw pictures to help you understand.

• insert The method needs to find where the character fits into the tree and add a new node. Consider the cases of putting it in the left tree and putting it in the right tree. For each of those, insert recursively in an existing tree or add a new node if there is no child in that direction. Don't fall off to null because you won't be able to connect the new node into the tree.
• remove The method needs to remove one copy of the target from the tree if the target is in the tree. But you need to make sure that the tree stays connected and organized. Consider the four cases of null, looking in the left tree, looking in the right tree, or removing it from this node (and fixing the tree). In fixing the tree, if the left tree is null, just move up the right. That will involve replaceChild. But if the left isn't null, use dataFromDeletedRightmost to replace this node's data with the largest value in the left tree and remove the node where that largest value was found.
• dataFromDeletedRightmost The method finds the largest value in the tree, and both returns it and replaces its place in the tree with its left subtree which may be null. To be able to replace it, you need the parent and can call replaceChild. Where is the largest value in a binary search tree? Page 499 in the text should help. It's easier than it sounds. Be sure to pass the found value back through the recursive calls.
• replaceChild The method takes a parent, the old child being replaced, and the new child that replaces it. Check whether the old child is the left or right child of the parent and attach the new child appropriately. This method is not recursive. It's just an if-else based on whether two nodes are the same node (== is appropriate) and setting children.