Part I – AVL Trees

Unbalanced Binary Search Tree5

4 8

1

2

3

7

6

9

12

11

10

Number of comparisons needed to search for NOV: 6.

Average number of comparisons: 3.5

Skew Binary Search TreeConsider 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

Binary Search TreeConsider 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

12107

Binary Search Trees:Balanced vs. UnbalancedThe 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.

Height-BalancedDefinition

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 h≦ L and hR are heights of TL and TR, respectively.

Examples

5

4 8

1

2

3

7

6

9

12

11

10

6

4 9

2

1

5 8

3

11

12107

Not height-balanced Height-balanced

Balance FactorDefinition:

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.

Balance Factors for an AVL Tree

0 0

0 0

1

0

-1 0

1

0

-1

1

-1

Construction of an AVL Tree Consider to insert the following numbers:

8, 9, 10, 2, 1, 5, 3, 6, 4, 7, 11, 12

8

0

8

-1

9

0

Insert 8 Insert 9

10

0

8

-2

9

-1

Insert 10

RR

insert in the right subtree of the

right subtree of A

Consider the nearest parent A

with bf = ±2

10

0

8

0

9

08

9

Insert 2

10

0

8

1

9

1

2

0

Insert 1

LL

insert in the left subtree of the

left subtree of A

Consider the nearest parent A

with bf = ±2

10

0

8

2 9

2

2

1

1

0

8

10

0

2

0 9

1

1

0

8

02

Insert 5

LR

insert in the right subtree of the

left subtree of A

Consider the nearest parent A with bf = ±2

10

0

2

-1 9

2

1

0

8

1

5

0

9

8

9

-1

2

0 8

0

1

0

10

0

5

0

Insert 3

9

-1

2

-1 8

1

1

0

10

1

5

0

3

0

Insert 6

9

-1

2

-1 8

1

1

0

10

0

5

0

3

0

6

0

RL

insert in the left subtree of

the right subtree of A

Insert 4

9

-1

2

-2 8

2

1

0

10

1

5

0

3

-1

6

0

4

0

Consider the nearest

parent A with bf = ±2

2

3

9

-1

2

1

8

1

1

010

0

5

03

0

6

0

4

0

LR

Insert 7

9

-1

2

1

8

2

1

010

-1

5

03

-1

6

-1

4

0

7

0

8

5 9

-1

2

1

8

0

1

0

10

0

5

0

3

1

6

-1

4

0

7

0

RR

Insert 11

9

-2

2

1

8

-1

1

0

10

-1

5

-1

3

1

6

-1

4

0

7

0

11

0

9

10

10

0

2

1

8

0

1

0

9

0

5

0

3

1

6

-1

4

0

7

0

11

0

Insert 12

10

-1

2

1

8

-1

1

0

9

-1

5

0

3

1

6

-1

4

0

7

0

11

-1

12

0

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

CTA

TB

LL

B

C A

TATB

Rotation Types (2)LR: Y is inserted in the right subtree of the left subtree

of A

A

B

C

TA

TCL TCR

LR

C

B A

TATCL TCR

Rotation Types (3)RR: Y is inserted in the right subtree of the right

subtree of A.

A

B

C

TA

TB

RR A

B

C

TA TB

Rotation Types (4)RL: Y is inserted in the left subtree of the right subtree

of A

A

B

C

TA

TCL TCR

RL A B

C

TA TCL TCR

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; };

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

Store the value of balance factor of the

node

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

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

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; }

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; }

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

//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

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; } else { p->bf = 1; p = p->leftChild; }}

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; }}

9

-1

2

-1 8

1

1

0

10

0

5

0

3

0

6

0

4

y

a

pa

p

d=-1

1

-1p

p

b

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; }

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

CTA

TB

a

b B

C A

a

TATB

b

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 }}

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

B

C

TA

TCL TCR

a

b

c

C

B A

TATCL TCR

a

c

b

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;}

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;} LL

102

9

1 8

108

9

2

1

8

2

pa

a

b

pa

b

a