1. CS200: Algorithms Analysis

2. BINARY SEARCH TREES
Important data structure for dynamic sets – dictionary or priority queue. Many BST operations are performed in O(h) where h is height of tree.
Node in tree is a record with 5 fields : pointer to parent node, pointer to left/right child, key and data.
Do example tree that stores characters in lexicographical or numerical order (next slide).

3. Root?
Leaf?
Interior Node?
Parent/child?
Sub-tree?
This nearly complete BST is well balanced –> log n runtimes.

4. Another well balanced example.

5. An unbalanced BST giving linear runtimes.

6. BINARY SEARCH TREE PROPERTY:
1. if y is left sub-tree of x then key[y] <= key[x].
2. if y is right sub-tree of x then key[y] > key[x].
Pulling keys out of tree in sorted order requires an INORDER walk of the tree.

7. InorderTreeWalk(x) //start at root
if x != null then
InorderTreeWalk(Left[x])
print(key[x])
InorderTreeWalk(Right[x])
Show sequence of output using example tree. ABDFHK. Do walk.
Runtime of tree walk with an n-node BST ?

8. Other operations : Searching and Insertion.
Where is minimum? maximum?
TreeSearch(x,k) //x starts at root, k is key
if (x = nil) or (k = key[x]) then
return x
else
if k < key[x] then
return TreeSearch(left[x],k)
return TreeSearch(right[x],k)
Trace algorithm by searching for 4 and 10 in example tree. If k is not in tree then return nil.

9. Runtime of TreeSearch=____________?
Insertion of x in a BST: code is similar to search code above. It is modified by placing x at a leaf in the proper sub-tree. The code uses a trailing back- pointer to keep track of parent of current node (same idea as inserting into a linked list).
Trace algorithm by inserting 18 in tree.
Runtime of Insertion = _____________?
Worst case runtime of Insertion = ______? This occurs when tree is ______________.
For now assume best case structure for BST is _______? Later we will look at algorithms that ensure this structure.

10. Do BST Activity in pairs.

11. SORTING OF BST’s Sort(A) for i = 1 to n do TreeInsert(A[i])
InorderTreeWalk(root)
Do example trace of algorithm. Notice similarity to Quicksort’s Partition algorithm. In this case though, no reordering of partition elements occurs.
Each element requires same comparisons as in Quicksort but in a different order.

12. Discuss the comparisons made for the example trace.
Since the runtime is proportional to # of comparisons made, the average time is the same as Quicksort = O(n logn).
Quicksort is better: in place sort, no additional data structure, small constants.

13. BST OPERATIONs
Minimum (maximum) is a required operation for priority queues. BST as a priority queue implements minimum as:
TreeMinimum(x) //x is pointer to root
while left[x] != null then
x = left[x]
return x
Runtime for tree minimum ?

14. Successor operation retrieves successor node of x
Successor operation retrieves successor node of x. Successor node of x is node with key that immediately follows the key of x, in sorted order.
TreeSuccessor(x)
if right[x] != null then{if right, suc. is min in subtree}
return TreeMinimum(right[x])
y = parent[x]
while(y!=null) and(x=right[y]) do {else suc. is back up
x=y tree to left of parent}
y =parent[y]
return y

16. Do an example trace of algorithm
Runtime of TreeSuccessor = ________?
Note that predecessor algorithm is analogous.

17. Deletion operation removes a node from the tree
Deletion operation removes a node from the tree. The following is a very informal pseudo code for operation.
TreeDelete(T,x)
if x has no children then {case 0}
remove x
if x has one child then {case 1}
make parent[x] point to child
if x has two children then {case 2]
swap x with its successor
perform case 0 or 1 to delete it

18. Do example trace for three cases of algorithm. See code next slide.
Note: the above swap could also be done with predecessor.
Runtime of Delete operation ?

20. D or A

21. Minimizing runtimes:
Problem: the worst case for operations on BST are ____________, which is no better than using a linked list representation for a priority queue.
Solution: guarantee that the BST is balanced which minimizes its height.
Method: restructure tree when necessary. Nothing special required for query operations but extra work needed when tree is modified via an insert or delete operation.

22. Summary
BST properties
algorithms and run-times
BST sorting