UMBC CMSC202, Computer Science II, Spring 1998, Sections 0101, 0102, 0103, 0104 and Honors

Tuesday April 28, 1998

Assigned Reading:

• A Book on C:
• Programming Abstractions in C:

Handouts (available on-line):

Topics Covered: This lecture and the next one is on Binary Search Trees (BST).

• Definition: a binary search tree satisfies the following two conditions.

  1. a BST is a binary tree.

  2. Each node of a BST is labeled with a key such that an inorder traversal of tree produces the keys in sorted order.

  The assumption here is that the keys can be ordered (e.g., the keys might be integers). For example, in Figure 1, an inorder walk of the tree will produce the keys 1, 2, 3, 5, 7, 9, 10.

  Fig 1. A binary search tree

• An equivalent way to think of a BST is that the root of a BST has children that are roots of subtrees that are BSTs and the key at the root is greater than or equal to any key in the left subtree and the key at the root is less than or equal to any key in the right subtree. This definition is recursive, so we should add the base case that an empty tree is a legal BST.

• There are many binary search trees that can hold a given set of keys. For example, both trees in Figure 1 and Figure 2 hold the set of keys {1, 2, 3, 5, 7, 9, 10} and both are legal binary search trees.

  Fig 2. Another binary search tree

• In the extreme, case we could have a BST holding {1, 2, 3, 5, 7, 9, 10} with 1 at the root and only right subtrees. So, 2 would be a right child of 1, 3 a right child of 2, etc. This tall and skinny tree is essentially a linked list. We shall see that the Search, Insert and Delete operations run in time proportional to the height of a BST. Thus, we prefer to have a short and squat tree rather than a tall and skinny tree.

• A binary tree with n nodes and height proportional to log n is called a balanced binary tree. There are techniques for keeping a BST balanced after any arbitrary sequence of insertions and deletions (e.g., AVL trees, Red-Black trees and 2-3 Trees). We will not discuss these techniques here. Nevertheless, we should note that in the balanced case, the running time for Search, Insert and Delete are O(log n) for a BST.

• Searching a BST for a given key can be done easily by recursion. We check if the given key k is equal to the key at the root of the BST. If it is, then we have found a node with key k and we are done. Otherwise, we compare k against the key at the root. If k is smaller, we recursively search the left subtree. Otherwise we recursively search the right subtree.

• Searching for the minimum and maximum element of a BST is also easy. To find the node with the smallest key, we start at the root and we keep checking for a left child. The first node that has no left child must have the smallest key in the BST, since every node of the BST is to its right. Finding the largest element is analogous.

• Inserting into a BST is similar to Search. To insert, we compare the given key k against the root, if the key k is less than or equal to the key at the root, we insert in the left subtree. Otherwise, we insert in the right subtree. If the subtree is empty, then we create a new node there with the given key. Figure 3 shows the result of insert 6 and 8 into the BST in Figure 2.

  Fig 3. After inserting 6 and 8.

• Deleting a node from a BST is more complicated. There are 3 cases to consider. The node we want to delete may have 0, 1 or 2 children. The case of 0 children (the node is a leaf) is easiest. We simply remove the node from the BST. Figure 4 shows the result of deleting the node 3 from the BST in Figure 3.

  Fig 4. A BST before and after deleting 3.

• If we are deleting a node with only 1 child, then we can let that child take the place of the node we are deleting. (I.e., if we are deleting node x, then the only child of x becomes a child of the parent of x). Figure 5 shows the result of deleting the node 2 from our BST.

  Fig 5. A BST before and after deleting 2.

• In the remaining case, the node we want to delete has 2 children. In this case, we find the node with the smallest key in the right subtree, remove that node and let it take the place of the node we are deleting. Why does this work? First, the node x with the smallest key in the right subtree can have at most 1 child. So, deleting this node can be handled by one of the previous cases. Second, the node x is the node smallest node with a key that is larger than the key in the node we are deleting. Since there isn't a node with a key in between x and the node we are deleting, we preserve the ordering of the keys in the BST. Figure 6 shows the result of deleting the root 7 from our BST. The node with the smallest key in the right subtree of 7 is 8. So, in the resulting BST, 8 becomes the new root.

  Fig 6. A BST before and after deleting 7.

• Next, we had an in depth discussion on how to define a class for binary search trees. One solution is the declarations in the header file bstree.h. An advantage of this declaration is that the structure is recursive. That is, an object of type BSTree points to a BSTreeNode that has members, called left and right, that are BSTrees. If left and right were pointers to BSTreeNode, then we would have to write separate routines for Insert, Search and Delete for BSTree and for BSTreeNode. Another advantage of this declaration is that it handles empty trees rather well. The "object" lesson here (pardon the pun) is that you should spend some time to think through the design of classes. A good design is not necessarily obvious. Time spent on a good design saves you time later when you implement and debug your classes.

• Since a BSTree object points to a BSTreeNode and a BSTreeNode has BSTree members, we have a circular reference. This cycle can be broken by adding a "class prototype" at the top of the file: class BSTreeNode ; This mechanism allows the BSTree declaration to have pointers to BSTreeNode before the BSTreeNode class is fully defined.

• Discussion on the implementation of this class will be finished in the next lecture.