Chapter 10 Efficient Binary Search Trees

1. Chapter 10Efficient Binary Search Trees Part I – AVL Trees

2. Unbalanced Binary Search Tree 5 • Number of comparisons needed to search for NOV: 6. • Average number of comparisons: 3.5 4 8 1 7 9 2 6 12 11 3 10

3. Skew Binary Search Tree • Consider the keys are entered in lexicographic order. • In worst case, searching a skew binary tree corresponds to sequential search in a ordered linked list. 1 2 3 4 5 6 7 8

4. Binary Search Tree 6 • Consider a balanced binary search tree as illustrated. • Number of comparisons needed to search for NOV: 6. • Average number of comparisons: 3.1 4 9 2 5 8 11 1 3 7 10 12

5. Binary Search Trees:Balanced vs. Unbalanced • The average and maximum search time can be minimized if the binary search tree is maintained as a complete binary tree all the times. • The time becomes O(log n) for an n-node binary search tree. • AVL tree (1962) • Balanced binary search tree with respect to the heights of subtrees. • Any retrievals can be performed in O(log n) time. • The resulting tree of insertion or a deletion remains height-balanced.

6. Height-Balanced • Definition • An empty tree is height-balanced. • If T is nonempty binary tree with TL and TR as its left and right subtrees respectively. • T is height-balanced iff • TL and TR are height-balanced, and • |hL-hR|≦1 where hL and hR are heights of TL and TR, respectively.

7. Examples 5 6 4 8 4 9 1 7 9 2 5 8 11 2 6 1 3 7 10 12 12 11 3 10 Not height-balanced Height-balanced

8. Balance Factor • Definition: • For every node T, define its balance factor, BF(T), as BF(T) = hL - hR where hL and hR are the heights of the left and right subtrees of T. • BF(T) for any node T in an AVL tree is –1, 0, or 1.

9. Balance Factors for an AVL Tree -1 1 1 -1 0 1 0 0 -1 0 0 0 0

10. Construction of an AVL Tree • Consider to insert the following numbers: • 8, 9, 10, 2, 1, 5, 3, 6, 4, 7, 11, 12 0 -1 8 8 0 9 Insert 8 Insert 9

11. Consider the nearest parent A with bf = ±2 -2 8 8 0 RR 9 -1 9 9 0 0 8 10 0 insert in the right subtree of the right subtree of A 10 Insert 10

12. 1 9 1 0 8 10 0 2 Insert 2

13. 2 Consider the nearest parent A with bf = ±2 9 1 2 0 9 8 8 10 0 0 1 LL 2 10 2 2 0 0 0 1 8 1 insert in the left subtree of the left subtree of A Insert 1

14. Consider the nearest parent A with bf = ±2 0 2 8 9 9 0 -1 -1 0 LR 2 9 2 10 0 0 0 0 1 1 5 10 1 8 8 insert in the right subtree of the left subtree of A 0 5 Insert 5

15. 1 1 8 8 -1 -1 -1 -1 2 9 2 9 0 0 0 0 1 0 1 1 5 10 5 10 0 0 0 3 3 6 Insert 3 Insert 6

16. Consider the nearest parent A with bf = ±2 1 2 8 8 0 -1 -2 -1 3 9 2 2 9 0 1 0 0 0 RL 1 1 2 5 10 5 10 0 0 0 -1 0 1 4 6 3 3 6 insert in the left subtree of the right subtree of A 0 4 Insert 4

17. 0 2 5 8 8 0 -1 -1 1 3 9 3 8 LR 0 1 -1 -1 1 0 -1 2 5 5 10 9 2 4 6 0 0 0 0 0 -1 1 1 7 10 4 6 0 7 Insert 7

18. 0 5 0 1 3 8 0 -1 1 0 -1 5 10 2 4 6 0 -1 0 0 0 1 1 3 7 9 11 8 -2 1 0 -1 RR 9 9 2 4 6 0 0 -1 1 7 10 10 0 11 Insert 11

19. -1 5 -1 1 8 3 1 0 -1 -1 10 2 6 4 0 0 -1 0 1 7 9 11 0 12 Insert 12

20. Rotation Types (1) • Suppose Y is the new node. • LL: Y is inserted in the left subtree of the left subtree of A. A B B LL C A TA C TB TB TA

21. Rotation Types (2) • LR: Y is inserted in the right subtree of the left subtree of A A C LR TA B B A C TCL TCR TA TCL TCR

22. Rotation Types (3) • RR: Y is inserted in the right subtree of the right subtree of A. A B RR B TA A C C TB TA TB

23. Rotation Types (4) • RL: Y is inserted in the left subtree of the right subtree of A C A RL A B TA B C TA TCL TCR TCL TCR

24. The Class Definition of AVL Tree class AvlNode { friend class AVL; public: AvlNode(int k) {data = k; bf = 0; leftChild = NULL; rightChild = NULL; } private: int data; int bf; AvlNode *leftChild, *rightChild; }; class AVL { public: AVL() : root(0) {}; bool Search(int key); bool Insert(int key); bool Delete(int key); private: AvlNode *root; }; Store the value of balance factor of the node

25. Phase 1 bool AVL::Insert(int key) { if (!root) { root = new AvlNode(key); return true; } //Phase 1: locate insertion point for key AvlNode *a = 0, //most recent node with bf = ± 1 *pa = 0, //parent of a *p = root, //p moves through the tree *pp = 0; //parent of p

26. while (p) { if (p->bf != 0) { a = p; pa = pp; } if (k > p->key) { pp = p; p = p->rightChild; } else if (k < p->key) { pp = p; p = p->leftChild; } else return false; }

27. Phase 2 //Phase 2: Insert and rebalance //k is not in the tree and may be inserted as the appropriate child of pp. AvlNode *y = new AvlNode(k); if (k < pp->key) pp->leftChild = y; //insert as left Child else pp->rightChild = y; //insert as right Child

28. int d; AvlNode *b, //child of a *c; //child of b if (a == NULL) { p = root; d = (k > p->key)? -1 : 1; } else if (k > a->key) { b = p = a->rightChild; d = -1; } else { b = p = a->leftChild; d = 1; } while (p != y) { if (k > p->key) { p->bf = -1; p = p->rightChild; } else { p->bf = 1; p = p->leftChild; } } 1 pa 8 • Adjust balance factors of nodes on path from a to pp. d=-1 -1 a -1 2 9 b 0 0 0 p 1 5 10 1 0 0 3 6 -1 p y 4 p

29. Rotation - LL if (a == NULL) return true; else if (a->bf==0 || a->bf+d == 0) { a->bf += d; return true; } if (d == 1) //left imbalance { if (b->bf == 1) //rotation type LL { a->leftChild = b->rightChild; b->rightChild = a; a->bf = 0; b->bf = 0; } a b A B b a B C A TA C TB TB TA

30. Rotation - LR A else //rotation type LR { c = b->rightChild; b->rightChild = c->leftChild; a->leftChild = c->rightChild; c->leftChild = b; c->rightChild = a; switch (c->bf) { case 1: a->bf = -1; b->bf = 0; break; case -1: b->bf = 1; a->bf = 0; break; case 0: b->bf = 0; b->bf = 0; break; } c->bf = 0; b = c; //b is the new root } } TA B a C C TCL TCR b B A c c TCL TCR TA b a

31. 9 8 8 10 2 2 1 else { //right imbalance. This is symmetric to left imbalance } if (pa == NULL) root = b; else if (a == pa->leftChild) pa->leftChild = b; else pa->rightChild = b; return true; } 9 2 10 pa 1 8 pa a b b LL a