1902 CSCI - Spring 2008 - Lecture 27 - 2008-04-30
-----------------------------------------------
Last time
- Binary Search Trees
Agenda
- Binary Search Trees
- Deletion
- Some problems
- Data structure problem
============================================================
RECAP
- BSTs are a second good way (in addition to hash tables) to implement
the dictionary interface.
- inserting a key,value pair
- Make a node whose data is an Entry (key, value pair)
(The node must be comparable, with comparison done based on the
key)
- Add the node to the tree
- Looking up the value for a key
- Search the tree for key
- In both cases, the efficiency is O(log n) *if the tree is balanced*
- Advantage over hash table implementation
- Can produce a sorted list of keys in O(n) time
- EXERCISE: How? Recall the definition of a BST and the
traversals we've defined
==> An inorder traversal
- ??? How would you do this for a hash table?
============================================================
- Deleting a node from a BST: 3 cases
- Node has no children --> easy
- Node has one child --> easy
- Node has two children: not as easy!
- Key requirement:
- Must keep the BST a BST
- I.e., for all nodes:
- Children in left subtree are smaller
- Children in right subtree are larger
- There are three cases to consider:
- DRAW A TREE THAT ILLUSTRATES ALL THREE SITUATIONS
- (1) delete a leaf:
- Easy, just delete it.
- (2) Delete a node with one child:
- Delete node
- Attach orphaned child to tree where deleted node was
- Still a BST
- (3) Delete a node with _two_ children
- Harder!
- If we delete the node, we are left with two orphaned to children
deal with.
- TASK:
- How can we fix this?
- Take a few minutes to try to figure it out
- HINT: SHOW A TREE WITH THREE NODES, DELETE THE ROOT
- How can we do it?
- Don't do it!
- Aside: a good programmer knows when to be lazy!
- We are side-stepping a hard problem, turning it into an easy one
- Reasoning:
- Let's list the children of some two-child node R:
a_n < a_n-1 < ... < a_2 < a_1 < R < b_1 < b_2 < ... < b_m-1 < b_m
- Because R has two children, we know that n >= 1 and m >= 1,
specifically, b_1 _must_ exist
- If we replace R with b_1, we can keep the BST property
- This is the key
- b_1 will:
- be the leftmost node in R.right (inorder successor)
- have at most one child:
otherwise, some other node would be smaller!
- Delete b_1, which we know how to do
- Replace R's value with b_1's
- (Similarly, we could use a_1 -- arbitrary choice)...