Binary Search Tree

PreliminariesSearch

ArrayListStack?Queue?For large amounts of input, the linear access

time of lists is prohibitive

PreliminariesTree

A collection of nodesThe collection can be emptyOtherwise, the tree consists of a distinguished

node r, called the root, and zero or more (sub)trees T1, T2, T3, …, Tk, each of whose roots are connected by a directed edge to r.

The root of each subtree is said to be a child of r, and r is the parent of each subtree root

Preliminaries

root

T1 T2 T3 T4 Tk

…

Preliminaries

TreeA tree is a collection of n nodes, one of which

is the root, and n-1 edges.Each edge connects some node to its parent and

every node except the root has one parent

Preliminaries

A

B C D FE G

H I J L M N O

P Q

LEAF LEAF

LEAF LEAF

LEAVES

LEAVES

INTERNAL NODES

ROOT

INTERNAL NODES

Binary TreeA binary tree is a tree in which no node

can have more than two children

root

TL TR

Binary Tree

A

D E

H I J L

P Q

ImplementationNodeclass node{public:

int item;node *left;node *right;node(int x) { item = x; left = right = NULL; }node( ) { item = 0; left = right = NULL; }

};

Expression Trees+

+ *

a *

b c

+ g

* f

d e

(a+b*c)+((d*e+f)*g)

Binary Search TreeAn application of binary trees is their use in

searchingLet us assume that each node in the tree is

assigned a key value, and assume that this is an integer

The property that makes a binary tree into a binary search tree is that for every node, X, in the tree, the values of all keys in the left subtree are smaller than the key value in X, and the values of all keys in the right subtree are larger than the key value in X.

Binary Search Tree

6

2 8

1 4

3

6

2 8

1 4

3 7

Binary Search Treeclass BST{private:

int size;node *root;

public:BST() {size = 0; root = NULL;}void insert(int);bool delete(int);bool search(int);int minimum();int maximum();

};

Binary Search Tree (Search)

6

2 8

1 4

3

20

10 50

Search for 10

Binary Search Tree (Search)bool BST::search(int x){

node *tmp = root;while(tmp!=NULL){

if(x == tmp->item)return true;

if(x < tmp->item)tmp = tmp->left;

elsetmp = tmp->right;

}return false;

}

Binary Search Tree (Minimum)

6

2 8

1 4

3

20

10 50-5

-1

Binary Search Tree (Minimum)

int BST::minimum(){

node *tmp = root;

while(tmp->left != NULL)

tmp = tmp -> left;

return temp->item;

}

Binary Search Tree (Insert)

6

2 8

1 4

3

20

10 50

Insert 20, 10, 50

Binary Search Tree (Insert)

Let’s insert 6, 2, 4, 3, 1, 8 and 11 in an empty BST

6

2 8

1 4

3

11

Binary Search Tree (Insert)Try inserting 1, 2, 3, and 4 in an empty

BST.1

2

3

4

Binary Search Tree (Insert)void BST::insert(int x){

node *n = new node(x);node *tmp = root;if(tmp = NULL)

root = n;else{

node *tmp2;while(tmp!=NULL){

tmp2 = tmp;if(x < tmp->item)

tmp = tmp->left;else

tmp = tmp->right;}if(x < tmp2->item)

tmp2->left = n;else

tmp2->right = n;}

}

BST (Delete)In deletion, we don’t ask for a position.

We ask for the actual item that has to be deleted.

6

2 8

1 4

3

Deleting a leaf

11

Deleting a node with one child

Deleting a node with two children

Deleting a Leaf (-1)

6

2 8

1 4

3

20

10 50-5

-1

Deleting a Node with a Child(-5)

6

2 8

1 4

3

20

10 50-5

-1

Deleting a node with two children (2)

6

2 8

1 4

3

20

10 50-5

-1

3

DeleteNode Code

bool BST::deleteNode(int x){

node *del = searchNode(x);

if(del->left == NULL && del->right==NULL)

delete del; //leaf

else{

}

}

One Child

if(del->left==NULL)

del = del->right;

else

if(del->right==NULL)

del = del->left;

Two Children

else{

node *ptr = minimum(del->right);

int x = ptr->item;

deleteNode(x);

del->item = x;

}

Running of Operations

Linear

1

2

3

4

Discussion We did not achieve our goal of log n. Can we improve? Always keep the tree balanced A

D E

H I J L

P Q

Adelson-Velski Landis (AVL) Tree

An AVL tree is a binary search tree where every node of the tree satisfies the following property:The height of the left and right subtrees of a

node differs by at most one.

Adelson-Velski Landis (AVL) Tree

Adelson-Velski Landis (AVL) Tree

In order to properly implement the AVL, the node has to be redefined.

class node{public:

int item;node *left;node *right;int height;node(int x) { item = x; left = right = NULL; }node( ) { item = 0; left = right = NULL; }

};

Adelson-Velski Landis (AVL) Tree

What kinds of violations may occur in a regular BST that will result in height imbalance?

1

2

3

3

2

1

3

1

2

Right Rotate

1

2

3

2

31

Left-Rotate

2

31

Left-Right Rotate

3

1

2

2

31

Right-Left Rotate

3

2

1

3

2

1

2

31

Challenge

Insert the following items in an AVL10, 20, 30, 40, 50, 60, 70, 80, 71, 61, 51, 41,

31, 21, 11

Right Rotate

void BST::rightRotate(node *r){

node *p = r->left;

r->left = p->right;

p->right = r;

//fill in the missing code

}

Left Rotate

void BST::leftRotate(node *r){

node *p = r->right;

r->right= p->left;

p->left= r;

//fill in the missing code

}

Other Rotations

I leave this as an exercise

Insertvoid BST::insert(int x){

//do insert as in BST

current = x;

set current to balanced

do{

previous = x;

update height of current

lh = height of the left subtree of current

rh = height of the left subtree of current

set current as left leaning, right leaning, or balanced

if(violation occurs)

perform corresponding rotation

}while(??);

}