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

2. Unbalanced Binary Search Tree
Number of comparisons needed to search for NOV: 6.
Average number of comparisons: 3.5 5 4 8 1 2 3 7 6 9 12 11 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
Consider a balanced binary search tree as illustrated.
Number of comparisons needed to search for NOV: 6.
Average number of comparisons: 3.1 6 4 9 2 1 5 8 3 11 12 10 7

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 Not height-balanced Height-balanced 5 4 8 1 2 3 7 6 9 12 1110 6 4 9 2 1 5 8 3 11 12 10 7
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 Tree1 -1

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

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

12. 1 9 1 8 10 2
Insert 2

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

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

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

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

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

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

19. -1 5 1 -1 3 8 1 -1 -1 10 2 4 6 -1 1 7 9 11 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 {
AVL() : root(0) {};
bool Search(int key);
bool Insert(int key);
bool Delete(int key);
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)
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. Adjust balance factors of nodes on path from a to pp.
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;
p->bf = 1; p = p->leftChild; 1 pa 8
d=-1 -1 a -1 2 9 b p 1 1 5 10 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; }
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 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 a A B C TA
TCL
TCR b c c C B A TA
TCL
TCR b a

31. 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; 10 8 9 2 1 pa pa 10 2 9 1 8 a b b LL a