UMBC CMSC202, Computer Science II, Fall 1998, Sections 0101, 0102, 0103, 0104

23. Binary Search Trees

Tuesday November 24, 1998

Assigned Reading:  none

Handouts (available on-line): Project 5

Programs from this lecture:

• Binary Search Trees

Topics Covered:

• This lecture covers Binary Search Trees (BST). We will return to expression trees in the next lecture, after Thanksgiving.

  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 considered a template class for binary search trees. (See bstree.h.) This class design is similar to the one for binary trees in Lecture 22. Recall that this design handles the case of empty trees rather well. We exploit this feature in the recursive implementations of member functions like insert(). Note that in the entire implementation of the BSTree class we do not use any loops. Everything is handled recursively, as it should be. This gives us a simple and concise implementation that is easy to debug if any errors should crop up.

  • First program and sample run demonstrates the simple use of the BSTree template class to create a binary search tree of integers.

  • Second program and sample run shows the delete feature of the BSTree class in a more complicated main program.

  • Third program and sample run: obligatory use of the template class with a different type.
   

• Discussed Project 5.