CSE 326: Data Structures Lecture #8 Binary Search Trees Alon Halevy Spring Quarter 2001.

CSE 326: Data StructuresLecture #8

Binary Search Trees

Alon Halevy

Spring Quarter 2001

Binary Trees

• Many algorithms are efficient and easy to program for the special case of binary trees

• Binary tree is– a root

– left subtree (maybe empty)

– right subtree (maybe empty)

A

B

D E

C

F

HG

JI

Binary Search Tree Dictionary Data Structure

4

121062

115

8

14

13

7 9

• Search tree property– all keys in left subtree

smaller than root’s key

– all keys in right subtree larger than root’s key

– result:• easy to find any given key

• inserts/deletes by changing links

Example and Counter-Example

3

1171

84

5

4

111062

185

8

BINARY SEARCH TREE NOT ABINARY SEARCH TREE

7

In Order Listing

visit left subtree

visit node

visit right subtree

2092

155

10

307 17

In order listing:25791015172030

Finding a Node

Node *& find(Comparable x,

Node * root) {

if (root == NULL)

return root;

else if (x < root->key)

return find(x,

root->left);

else if (x > root->key)

return find(x,

root->right);

else

return root;

}

2092

155

10

307 17

runtime:

InsertConcept: proceed down tree as in Find; if new key not found,

then insert a new node at last spot traversed

void insert(Comparable x, Node * root) {assert ( root != NULL );if (x < root->key){

if (root->left == NULL)root->left = new Node(x);

else insert( x, root->left ); }else if (x > root->key){

if (root->right == NULL)root->right = new Node(x);

else insert( x, root->right ); } }

BuildTree for BSTs

Suppose a1, a2, …, an are inserted into an initially empty BST:

1. a1, a2, …, an are in increasing order

2. a1, a2, …, an are in decreasing order

3. a1 is the median of all, a2 is the median of elements less than a1, a3 is the median of elements greater than a1, etc.

4. data is randomly ordered

Examples of Building from Scratch

• 1, 2, 3, 4, 5, 6, 7, 8, 9

• 5, 3, 7, 2, 4, 6, 8, 1, 9

Analysis of BuildTree• Worst case is O(n2)

1 + 2 + 3 + … + n = O(n2)

• Average case assuming all orderings equally likely is O(n log n)– not averaging over all binary trees, rather averaging

over all input sequences (inserts)– equivalently: average depth of a node is log n– proof: see Introduction to Algorithms, Cormen, Leiserson, & Rivest

Bonus: FindMin/FindMax

• Find minimum

• Find maximum 2092

155

10

307 17

Deletion

2092

155

10

307 17

Why might deletion be harder than insertion?

Deletion - Leaf Case

2092

155

10

307 17

Delete(17)

Deletion - One Child Case

2092

155

10

307

Delete(15)

Deletion - Two Child Case

3092

205

10

7

Delete(5)

replace node with value guaranteed to be between the left and

right subtrees: the successorCould we have used the predecessor instead?

Finding the Successor

Find the next larger nodein this node’s subtree.

– not next larger in entire tree

Node * succ(Node * root) { if (root->right == NULL) return NULL; else return min(root->right);}

2092

155

10

307 17

How many children can the successor of a node have?

Predecessor

Find the next smaller node

in this node’s subtree.

Node * pred(Node * root) {

if (root->left == NULL)

return NULL;

else

return max(root->left);

}

2092

155

10

307 17

Deletion - Two Child Case

3092

205

10

7

Delete(5)

always easy to delete the successor – always has either 0 or 1 children!

Delete Codevoid delete(Comparable x, Node *& p) {

Node * q;

if (p != NULL) {

if (p->key < x) delete(x, p->right);

else if (p->key > x) delete(x, p->left);

else { /* p->key == x */

if (p->left == NULL) p = p->right;

else if (p->right == NULL) p = p->left;

else {

q = successor(p);

p->key = q->key;

delete(q->key, p->right);

}

}

} }

Lazy Deletion

• Instead of physically deleting nodes, just mark them as deleted+ simpler+ physical deletions done in batches+ some adds just flip deleted flag– extra memory for deleted flag– many lazy deletions slow finds– some operations may have to be

modified (e.g., min and max)

2092

155

10

307 17

Lazy Deletion

2092

155

10

307 17

Delete(17)

Delete(15)

Delete(5)

Find(9)

Find(16)

Insert(5)

Find(17)

Dictionary Implementations

BST’s looking good for shallow trees, i.e. the depth D is small (log n), otherwise as bad as a linked list!

unsorted

array

sorted

array

linked

list

BST

insert find + O(n) O(n) find + O(1) O(Depth)

find O(n) O(log n) O(n) O(Depth)

delete find + O(1) O(n) find + O(1) O(Depth)

Beauty is Only (log n) Deep

• Binary Search Trees are fast if they’re shallow:– e.g.: perfectly complete

– e.g.: perfectly complete except the “fringe” (leafs)

– any other good cases?

What matters here?Problems occur when onebranch is much longer than the other!

Balance

• Balance– height(left subtree) - height(right subtree)

– zero everywhere perfectly balanced

– small everywhere balanced enough

t

57

Balance between -1 and 1 everywhere maximum height of 1.44 log n

AVL Tree Dictionary Data Structure

4

121062

115

8

14137 9

• Binary search tree properties– binary tree property

– search tree property

• Balance property– balance of every node is:

-1 b 1– result:

• depth is (log n)

15

An AVL Tree

15

92 12

5

10

20

17

0

0

100

1 2

3 10

3

data

height

children

300

Not AVL Trees

15

12

5

10

20

170

10

0 2

3

300

15

10

200

1

2

(-1)-1 = -20-2 = -2

Staying Balanced

Good case: inserting small, tall and middle.

Insert(middle)

Insert(small)

Insert(tall)

M

S T00

1

Bad Case #1

Insert(small)

Insert(middle)

Insert(tall)

T

M

S

0

1

2

Single Rotation

T

M

S

0

1

2

M

S T00

1

Basic operation used in AVL trees:

A right child could legally have its parent as its left child.

General Case: Insert Unbalancesa

X

Y

b

Z

h h - 1

h + 1 h - 1

h + 2a

X

Y

b

Z

h-1 h - 1

h h - 1

h + 1

General Single Rotation

• Height of left subtree same as it was before insert!

• Height of all ancestors unchanged– We can stop here!

a

X

Y

b

Z

a

XY

b

Zh h - 1

h + 1 h - 1

h + 2

h

h - 1

h

h - 1

h + 1

Bad Case #2

Insert(small)

Insert(tall)

Insert(middle)

M

T

S

0

1

2

Will a single rotation fix this?

Double Rotation

M

S T00

1

M

T

S

0

1

2

T

M

S

0

1

2

General Double Rotation

• Initially: insert into either X or Y unbalances tree (root height goes to h+2)

• “Zig zag” to pull up c – restores root height to h+1, left subtree height to h

a

Z

b

W

c

X Y

a

Z

b

W

c

X Y

h

h - 1?

h - 1

h - 1

h + 2

h + 1

h - 1h - 1

h

h + 1

h

h - 1?

Insert Algorithm

• Find spot for value• Hang new node• Search back up looking for imbalance• If there is an imbalance:

case #1: Perform single rotation and exit

case #2: Perform double rotation and exit

Easy Insert

2092

155

10

3017

Insert(3)

120

0

100

1 2

3

0

Hard Insert (Bad Case #1)

2092

155

10

3017

Insert(33)

3

121

0

100

2 2

3

00

Single Rotation

2092

155

10

30173

12

33

1

0

200

2 3

3

10

0

3092

205

10

333

151

0

110

2 2

3

001712

0

Hard Insert (Bad Case #2)

Insert(18)

2092

155

10

30173

121

0

100

2 2

3

00

Single Rotation (oops!)

2092

155

10

30173

121

1

200

2 3

3

00

3092

205

10

3

151

1

020

2 3

3

01712

0

180

180

Double Rotation (Step #1)

2092

155

10

30173

121

1

200

2 3

3

00

180

1792

155

10

203

121 200

2 3

3

10

300

Look familiar?18

0

Double Rotation (Step #2)

1792

155

10

203

121 200

2 3

3

10

300

180

2092

175

10

303

151

0

110

2 2

3

0012

018

AVL Algorithm Revisited• Recursive1. Search downward for

spot

2. Insert node

3. Unwind stack,

correcting heights

a. If imbalance #1,

single rotate

b. If imbalance #2,

double rotate

• Iterative1. Search downward for spot, stacking parent nodes2. Insert node3. Unwind stack, correcting heights a. If imbalance #1, single rotate and exit b. If imbalance #2, double rotate and exit

Single Rotation Codevoid RotateRight(Node *& root) {

Node * temp = root->right;

root->right = temp->left;

temp->left = root;

root->height = max(root->right->height,

root->left->height) + 1;

temp->height = max(temp->right->height,

temp->left->height) + 1;

root = temp;

}

X

Y

Z

root

temp

Double Rotation Codevoid DoubleRotateRight(Node *& root) {

RotateLeft(root->right);

RotateRight(root);

}

a

Z

b

W

c

XY

a

Z

c

b

X

Y

W

First Rotation

Double Rotation Completed

a

Z

c

b

X

Y

W

a

Z

c

b

XY

W

First Rotation Second Rotation