Binary Search Tree

1. Binary Search Tree

2. Outline • Concept of Binary Search Tree (BST) • BST operations • Find • Insert • Remove • Running time analysis of BST operations

3. Binary Search Tree: Properties • Elements have keys (no duplicates allowed). • For every node X in the tree, the values of all the keys in the left subtreeare smaller than the key in Xand the values of all the keys in the right subtreearelarger than the key in X. • The keys must be comparable. X <X >X

4. 6 Binary Search Tree: Examples 7 9 2 1 5 3

5. Binary Search Tree: Examples 3 3 1 1 2 2 1 3 3 2 1 2 2 1 3

6. Basic Operations • FindMin, FindMax, Find • Insert • Remove

7. FindMin • Find node with the smallest value • Algorithm: • Keep going left until you reach a dead end! • Code: BinaryNode<Type> findMin(BinaryNode<Type> t) { if (t != null) while (t.left != null) t = t.left; return t; }

8. FindMax • Find node with the largest value • Algorithm: • Keep going right until you reach a dead end! • Code: BinaryNode<Type> findMax(BinaryNode<Type> t) { if (t != null) while (t.right != null) t = t.right; return t; }

9. 6 Find • You are given an element to find in a BST. If it exists, return the node. If not, return null. • Algorithm? • Code? 7 9 2 1 5 3

10. Find: Implementation BinaryNode<Type> find(Type x, BinaryNode<T> t) { while(t!=null) { if(x.compareTo(t.element)<0) t = t.left; else if(x.compareTo(t.element)>0) t = t.right; else return t; // Match } return null; // Not found }

11. 10 15 2 12 1 5 14 3 6 Insertion: Principle • When inserting a new element into a binary search tree, it will always become a leaf node.

12. Insertion: Algorithm • To insert X into a binary search tree: • Start from the root • If the value of X < the value of the root:X should be inserted in the left sub-tree. • If the value of X > the value of the root: X should be inserted in the right sub-tree. • Remember that a sub-tree is also a tree. • We can implement this recursively!

13. Insertion: Implementation BinaryNode<Type> insert(Type x, BinaryNode<Type> t) { if (t == null) t = new BinaryNode<Type>(x); else if(x.compareTo(t.element)<0) t.left = insert (x, t.left); else if(x.compareTo(t.element)>0) t.right = insert (x, t.right); else throw new DuplicateItemException(x); return t; }

14. 8 12 4 6 1 3 5 Removing An Element 4 6 5

15. Removing An Element: Algorithm • If the node is a leaf, simply delete it. • If the node has one child, adjust parent’s child reference to bypass the node. • If the node has two children: • Replace the node’s element with the smallest element in the right subtree and then remove that node, or • Replace the node’s element with the largest element in the left subtree and then remove that node • Introduces new sub-problems: • removeMin: • Alternatively, removeMax

16. Removing Leaf 8 12 4 6 1 3 5

17. Removing Node With 1 Child 8 12 4 6 1 3 5

18. Removing Node With 1 Child 8 12 4 6 1 3 5

19. removeMin BinaryNode<Type> removeMin(BinaryNode<Type> t) { if (t == null) throw new ItemNotFoundException(); else if (t.left != null) { t.left = removeMin(t.left); return t; } else return t.right; }

20. Removing Node With 2 Children 7 9 2 1 5 3 4

21. 3 Removing Node With 2 Children 7 2 9 3 1 5 3 4

22. Removing Node With 2 Children 7 2 9 2 3 1 5 3 4

23. 7 12 2 10 14 1 5 3 9 11 4 Removing Root 9

24. Remove BinaryNode<Type> remove(Type x, BinaryNode<Type> t) { if (t == null) throw new ItemNotFoundException(); if (x.compareTo(t.element)<0) t.left = remove(x, t.left); else if(x.compareTo(t.element)>0) t.right = remove(x, t.right); else if (t.left!=null && t.right != null) { t.element = findMin(t.right).element; t.right = removeMin(t.right); } else { if(t.left!=null) t=t.left; else t=t.right; } return t; }

25. Find k-th element X X X SL SR SL SR SL SR k < SL + 1 k == SL + 1 k > SL + 1

26. Find k-th element BinaryNode<Type> findKth(int k, BinaryNode<Type> t) { if (t == null) throw exception; intleftSize = (t.left != null) ? t.left.size : 0; if (k <= leftSize ) return findKth (k, t.left); else if (k == leftSize + 1) return t; else return findKth ( k - leftSize - 1, t.right); }

27. Analysis • Running time for: • Insert? • Find min? • Remove? • Find? • Average case: O(log n) • Worst case: O(n)

28. Summary • Binary Search Tree maintains the order of the tree. • Each node should be comparable • All operations take O(log n) - average case, when the tree is equally balanced. • All operations will take O(n) - worst case, when the height of the tree equals the number of nodes.