Chapter 10 Efficient Binary Search Trees

1 / 31

# Chapter 10 Efficient Binary Search Trees - PowerPoint PPT Presentation

Chapter 10 Efficient Binary Search Trees. Part I – AVL Trees. 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. Skew Binary Search Tree.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about 'Chapter 10 Efficient Binary Search Trees' - morag

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

### Chapter 10Efficient Binary Search Trees

Part I – AVL Trees

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

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

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

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

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

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

1

9

1

0

8

10

0

2

Insert 2

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

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

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

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

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

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

-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

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

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

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

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

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

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

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

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

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

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

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