CS-102 BST_27_3_14v2.pdf

Binary Search Trees
 Key property
 Value at node
 Smaller values in left subtree
 Larger values in right subtree
 Example
 X > Y
 X < Z
Y
X
Z

Binary Search Trees
 Examples
Binary
search trees
Not a binary
search tree
5
10
30
2 25 45
5
10
45
2 25 30
5
10
30
2
25
45

Binary Tree Implementation
Class Node {
int data; // Could be int, a class, etc
Node *left, *right; // null if empty
void insert ( int data ) { … }
void delete ( int data ) { … }
Node *find ( int data ) { … }
…
}

Iterative Search of Binary Tree
Node *Find( Node *n, int key) {
while (n != NULL) {
if (n->data == key) // Found it
return n;
if (n->data > key) // In left subtree
n = n->left;
else // In right subtree
n = n->right;
}
return null;
}
Node * n = Find( root, 5);

Recursive Search of Binary Tree
Node *Find( Node *n, int key) {
if (n == NULL) // Not found
return( n );
else if (n->data == key) // Found it
return( n );
else if (n->data > key) // In left subtree
return Find( n->left, key );
else // In right subtree
return Find( n->right, key );
}
Node * n = Find( root, 5);

Example Binary Searches
 Find ( root, 2 )
5
10
30
2 25 45
5
10
30
2
25
45
10 > 2, left
5 > 2, left
2 = 2, found
5 > 2, left
2 = 2, found
root

Example Binary Searches
 Find (root, 25 )
5
10
30
2 25 45
5
10
30
2
25
45
10 < 25, right
30 > 25, left
25 = 25, found
5 < 25, right
45 > 25, left
30 > 25, left
10 < 25, right
25 = 25, found

Types of Binary Trees
 Degenerate – only one child
 Full – always two children
 Balanced – “mostly” two children
 more formal definitions exist, above are intuitive ideas
Degenerate
binary tree
Balanced
binary tree
Full binary
tree

Binary Trees Properties
 Degenerate
 Height = O(n) for n
nodes
 Similar to linked list
 Balanced
 Height = O( log(n) )
for n nodes
 Useful for searches
Degenerate
binary tree
Balanced
binary tree

Binary Search Properties
 Time of search
 Proportional to height of tree
 Balanced binary tree
 O( log(n) ) time
 Degenerate tree
 O( n ) time
 Like searching linked list / unsorted array

Binary Search Tree Construction
 How to build & maintain binary trees?
 Insertion
 Deletion
 Maintain key property (invariant)
 Smaller values in left subtree
 Larger values in right subtree

Binary Search Tree – Insertion
 Algorithm
1. Perform search for value X
2. Search will end at node Y (if X not in tree)
3. If X < Y, insert new leaf X as new left subtree for
Y
4. If X > Y, insert new leaf X as new right subtree
for Y
 Observations
 O( log(n) ) operation for balanced tree
 Insertions may unbalance tree

Example Insertion
 Insert ( 20 )
5
10
30
2 25 45
10 < 20, right
30 > 20, left
25 > 20, left
Insert 20 on left
20

template<class E, class K>
class BSTree public: Binarytree<E>
{
public:
bool search(const K &k, E &e);
BSTree<E, K> &insert(E &e);
BSTree<E,K> &delete(K &k, E &e);
};
template<class E, class K>
BSTree<E,K> &BSTree<E,K>::insert(E &e)
{
BinaryTreeNode<E> *p=root;
BinaryTreeNode<E> *pp=0;
while (p)
{pp=p;
if (e<pdata) p=pleftchild;
else if (e>pdata) p=prightchild;
else throw badinput();
}
BinaryTreeNode<E> *r=new BinaryTreeNode<E> (e)
if (root) {
if (e<ppdata) ppleftchild=r;
else pprightchild=r;}
else root=r;
return *this;
}

Binary Search Tree – Deletion
 Algorithm
1. Perform search for value X
2. If X is a leaf, delete X
3. Else // must delete internal node
a) Replace with largest value Y on left subtree
OR smallest value Z on right subtree
b) Delete replacement value (Y or Z) from subtree
Observation
 O( log(n) ) operation for balanced tree
 Deletions may unbalance tree

Example Deletion (Leaf)
 Delete ( 25 )
5
10
30
2 25 45
10 < 25, right
30 > 25, left
25 = 25, delete
5
10
30
2 45

Example Deletion (Internal Node)
 Delete ( 10 )
5
10
30
2 25 45
5
5
30
2 25 45
2
5
30
2 25 45
Replacing 10
with largest
value in left
subtree
Replacing 5
with largest
value in left
subtree
Deleting leaf

Example Deletion (Internal Node)
 Delete ( 10 )
5
10
30
2 25 45
5
25
30
2 25 45
5
25
30
2 45
Replacing 10
with smallest
value in right
subtree
Deleting leaf Resulting tree

Indexed Binary Search Tree
 Binary search tree.
 Each node has an additional field.
 leftSize = number of nodes in its left subtree+1

Example: Indexed Binary Search
Tree 20
10
6
2 8
15
40
30
25 35
7
18
1
1 2
2
5
1
1
8
1 1
2
4
leftSize values are in red
Also called Rank!

Balanced Search Trees
 Height balanced.
 AVL (Adelson-Velsky and Landis, 1962) trees
 Weight Balanced.
 Degree Balanced.
 2-3 trees
 2-3-4 trees
 red-black trees
 B-trees

AVL Tree
 binary tree
 for every node x, define its balance factor
balance factor of x = height of left subtree of x
– height of right subtree of x
 balance factor of every node x is – 1, 0, or
1

AVL Trees
An empty binary Tree is an AVL Tree. If T is a
non-empty Binary tree with and as its
left and right subtrees, then T is an AVL tree
iff (1) and are AVL trees and (2)
where and are the heights of and
L
T R
T
L
T R
T 1

 R
L h
h
L
h R
h L
T R
T

Balance Factors
0 0
0 0
1
0
-1 0
1
0
-1
1
-1
This is an AVL tree.

AVL Search Tree
 Binary Search Tree+AVL

Indexed AVL Search Tree
 Indexed Binary Search Tree+AVL

Height Of An AVL Tree
The height of an AVL tree that has n nodes is
at most 1.44 log2 (n+2).
The height of every n node binary tree is at
least log2 (n+1).
log2 (n+1) <= height <= 1.44 log2 (n+2)

Proof Of Upper Bound On Height
 Let Nh = min # of nodes in an AVL tree
whose height is h.
 N0 = 0.
 N1 = 1.
 In the worst case the height of one of the
subtrees is h-1, and the height of the other
is h-2.

Nh, h > 1
 Both L and R are AVL trees.
 The height of one is h-1.
 The height of the other is h-2.
 The subtree whose height is h-1 has Nh-1 nodes.
 The subtree whose height is h-2 has Nh-2 nodes.
 So, Nh = Nh-1 + Nh-2 + 1.
L R

Fibonacci Numbers
 F0 = 0, F1 = 1.
 Fi = Fi-1 + Fi-2 , i > 1.
 N0 = 0, N1 = 1.
 Nh = Nh-1 + Nh-2 + 1, i > 1.
 Nh = Fh+2 – 1.
 Fi ~ i/sqrt(5).
 sqrt

AVL Search Tree
0 0
0 0
1
0
-1 0
1
0
-1
1
-1
1
0
7
8
3
1 5
3
0
4
0
2
0
2
5
3
5
4
5
6
0

Balanced Search Trees
 Kinds of balanced binary search trees
 height balanced vs. weight balanced
 “Tree rotations” used to maintain balance on insert/delete
 Non-binary search trees
 2/3 trees
 each internal node has 2 or 3 children
 all leaves at same depth (height balanced)
 B-trees
 Generalization of 2/3 trees
 Each internal node has between k/2 and k children
 Each node has an array of pointers to children
 Widely used in databases

Other (Non-Search) Trees
 Parse trees
 Convert from textual representation to tree
representation
 Textual program to tree
 Used extensively in compilers
 Tree representation of data
 E.g. HTML data can be represented as a tree
 called DOM (Document Object Model) tree
 XML
 Like HTML, but used to represent data
 Tree structured

Parse Trees
 Expressions, programs, etc can be
represented by tree structures
 E.g. Arithmetic Expression Tree
 A-(C/5 * 2) + (D*5 % 4)
+
- %
A * * 4
/ 2 D 5
C 5

Tree Traversal
 Goal: visit every node of a tree
 in-order traversal
void Node::inOrder () {
if (left != NULL) {
cout << “(“; left->inOrder(); cout << “)”;
}
cout << data << endl;
if (right != NULL) right->inOrder()
}
Output: A – C / 5 * 2 + D * 5 % 4
To disambiguate: print brackets
+
- %
A * * 4
/ 2 D 5
C 5

Tree Traversal (contd.)
 pre-order and post-order:
void Node::preOrder () {
if (left != NULL) left->preOrder ();
if (right != NULL) right->preOrder ();
}
void Node::postOrder () {
if (left != NULL) left->preOrder ();
if (right != NULL) right->preOrder ();
}
Output: + - A * / C 5 2 % * D 5 4
Output: A C 5 / 2 * - D 5 * 4 % +
+
- %
A * * 4
/ 2 D 5
C 5

XML
 Data Representation
 E.g.
<dependency>
<object>sample1.o</object>
<depends>sample1.cpp</depends>
<depends>sample1.h</depends>
<rule>g++ -c sample1.cpp</rule>
</dependency>
 Tree representation
dependency
object depends
sample1.o sample1.cpp
depends
sample1.h
rule
g++ -c …

Graph Data Structures
 E.g: Airline networks, road networks, electrical circuits
 Nodes and Edges
 E.g. representation: class Node
 Stores name
 stores pointers to all adjacent nodes
 i,e. edge == pointer
 To store multiple pointers: use array or linked list
Ahm’bad
Delhi
Mumbai
Calcutta
Chennai
Madurai

CS-102 BST_27_3_14v2.pdf

Recommended

More Related Content

Similar to CS-102 BST_27_3_14v2.pdf (20)

More from ssuser034ce1 (20)

Recently uploaded (20)

CS-102 BST_27_3_14v2.pdf