Transcript
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
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
ImplementationNodeclass node{public:
int item;node *left;node *right;node(int x) { item = x; left = right = NULL; }node( ) { item = 0; left = right = NULL; }
};
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 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)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)
int BST::minimum(){
node *tmp = root;
while(tmp->left != NULL)
tmp = tmp -> left;
return temp->item;
}
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
DeleteNode Code
bool BST::deleteNode(int x){
node *del = searchNode(x);
if(del->left == NULL && del->right==NULL)
delete del; //leaf
else{
}
}
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
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
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
}
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(??);
}
top related