Binary Search Trees

Binary Trees
Binary tree is A
 a root
 left subtree (maybe empty)
 right subtree (maybe B C
empty)
D E F
Properties
 max # of leaves:
 max # of nodes:
G H
 average depth for N nodes:
Data I J
Representation: left right
pointer pointer
Binary Search CSE 326 Autumn 2001
Trees 2
 Binary Tree
Representation
A A
left right
child child

B C
B C
left right left right
child child child child D E F

D E F
left right left right left right
child child child child child child

Binary Search CSE 326 Autumn 2001

Trees 3
 Dictionary ADT
Dictionary operations insert Adrien
Donald Roller-blade
 create l33t haxtor
demon
 destroy Hannah
 insert C++ guru
Adrien find(Adrien)
 find Roller-blade demon Dave
 delete Older than dirt

…
Stores values associated with user-
specified keys
 values may be any (homogeneous)
type
 keys may be any (homogeneous)
comparable type
Binary Search CSE 326 Autumn 2001
Trees 4
 Dictionary ADT:
Used Everywhere
 Arrays
 Sets
 Dictionaries
 Router tables
 Page tables
 Symbol tables
 C++ structures
 …

Anywhere we need to find things fast based on a

key

Binary Search CSE 326 Autumn 2001

Trees 5
 Search ADT
Dictionary operations insert Adrien
Donald
 create Hannah
 destroy Dave
 insert
 find(Adrien) …
find Adrien
 delete

Stores only the keys

 keys may be any (homogenous) comparable
 quickly tests for membership

Simplified dictionary, useful for examples (e.g.

CSE 326)
Binary Search CSE 326 Autumn 2001
Trees 6
 Dictionary Data Structure:
Requirements
 Fast insertion
 runtime:

 Fast searching
 runtime:

 Fast deletion
 runtime:

Binary Search CSE 326 Autumn 2001

Trees 7
 Naïve Implementations
unsorted sorted linked list
array array
insert O(n) find + O(1)
O(n)
find O(n) O(log n) O(n)
delete find + find + find +
O(1) O(1) O(1)
(mark-as- (mark-as-
deleted) deleted)

Binary Search CSE 326 Autumn 2001

Trees 8
 Binary Search Tree
Dictionary Data Structure
Binary tree property
 each node has  2 children 8
 result:
 storage is small
 operations are simple 5 11
 average depth is small
Search tree property
 all keys in left subtree 2 6 10 12
smaller than root’s key
 all keys in right subtree
larger than root’s key 4 7 9 14
 result:
 easy to find any given key
 Insert/delete by changing links 13

Binary Search CSE 326 Autumn 2001

Trees 9
 Example and Counter-
Example
8
5
5 11
4 8
2 7 6 10 18
1 7 11
4 15 20
3
NOT A 21
BINARY SEARCH TREE BINARY SEARCH TREE
Binary Search CSE 326 Autumn 2001
Trees 10
 Complete Binary Search
Tree
Complete binary search
tree
(aka binary heap): 8
 Links are completely
filled, except possibly
bottom level, which is 5 15
filled left-to-right.
3 7 9 17

1 4 6

Binary Search CSE 326 Autumn 2001

Trees 11
 In-Order Traversal
10
visit left subtree
visit node
5 15
visit right subtree

2 9 20
What does this
guarantee with a
7 17 30 BST?

In order listing:
25791015172030
Binary Search CSE 326 Autumn 2001
Trees 12
 Recursive Find
10
Node *
find(Comparable key, Node * t)
5 15
{
if (t == NULL) return t;
2 9 20
else if (key < t->key)
return find(key, t->left);
7 17 30
else if (key > t->key)
return find(key, t->right);
Runtime: else
Best-worse case? return t;
Worst-worse case? }
f(depth)?
Binary Search CSE 326 Autumn 2001
Trees 13
 Iterative Find
10
Node *
find(Comparable key, Node * t)
5 15 {
while (t != NULL && t->key != key)
{
2 9 20
if (key < t->key)
t = t->left;
7 17 30 else
t = t->right;
}

return t;
}

Binary Search CSE 326 Autumn 2001

Trees 14
 Insert
void
Concept: insert(Comparable x, Node * t)
 Proceed down tree {
as in Find if ( t == NULL ) {
 If new key not t = new Node(x);

found, then insert } else if (x < t->key) {

a new node at last insert( x, t->left );
spot traversed
} else if (x > t->key) {
insert( x, t->right );

} else {
// duplicate
// handling is app-dependent
}
Binary Search CSE 326 Autumn 2001
Trees 15
 BuildTree for BSTs
 Suppose the data 1, 2, 3, 4, 5, 6, 7, 8, 9 is
inserted into an initially empty BST:
 in order

 in reverse order

 median first, then left median, right median,

etc.

Binary Search CSE 326 Autumn 2001

Trees 16
 Analysis of BuildTree
Worst case is O(n2)

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

Average case assuming all orderings equally likely:

O(n log n)
 averaging over all insert sequences (not over all binary
trees)
 equivalently: average depth of a node is log n
 proof: see Introduction to Algorithms, Cormen, Leiserson, &
Rivest

Binary Search CSE 326 Autumn 2001

Trees 17
 BST Bonus:
FindMin, FindMax
 Find minimum
10

5 15
 Find maximum
2 9 20

7 17 30

Binary Search CSE 326 Autumn 2001

Trees 18
 Successor Node
Next larger node
10
in this node’s subtree
Node * succ(Node * t) { 5 15
if (t->right == NULL)
return NULL;
else
2 9 20
return min(t->right);
}
7 17 30

How many children can the successor of a node have?

Binary Search CSE 326 Autumn 2001
Trees 19
 Predecessor Node
Next smaller node
10
in this node’s subtree
Node * pred(Node * t) { 5 15
if (t->left == NULL)
return NULL;
else 2 9 20
return max(t->left);
}
7 17 30

Binary Search CSE 326 Autumn 2001

Trees 20
 Deletion
10

5 15

2 9 20

7 17 30

Why might deletion be harder than insertion?

Binary Search CSE 326 Autumn 2001

Trees 21
 Lazy Deletion
Instead of physically deleting
nodes, just mark them as
deleted
+ simpler 10
+ physical deletions done in
batches
5 15
+ some adds just flip deleted flag
- extra memory for deleted flag
- many lazy deletions slow finds 2 9 20
- some operations may have to
be modified (e.g., min and max) 17 30
7

Binary Search CSE 326 Autumn 2001

Trees 22
 Lazy Deletion
Delete(17)
10
Delete(15)

Delete(5) 5 15

Find(9) 2 9 20
Find(16)
7 17 30
Insert(5)

Find(17)
Binary Search CSE 326 Autumn 2001
Trees 23
 Deletion - Leaf Case
Delete(17) 10

5 15

2 9 20

7 17 30

Binary Search CSE 326 Autumn 2001

Trees 24
 Deletion - One Child Case
Delete(15) 10

5 15

2 9 20

7 30

Binary Search CSE 326 Autumn 2001

Trees 25
 Deletion - Two Child Case
Replace node with
descendant whose value is 10
guaranteed to be between
left and right subtrees: the 5 20
successor

2 9 30

Delete(5)
7

Could we have used predecessor instead?

Binary Search CSE 326 Autumn 2001

Trees 26
 Delete Code
void delete(Comparable key, Node *& root) {
Node *& handle(find(key, root));
Node * toDelete = handle;
if (handle != NULL) {
if (handle->left == NULL) { // Leaf or one child
handle = handle->right;
delete toDelete;
} else if (handle->right == NULL) { // One child
handle = handle->left;
delete toDelete;
} else { // Two children
successor = succ(root);
handle->data = successor->data;
delete(successor->data, handle->right);
}
}
}

Binary Search CSE 326 Autumn 2001

Trees 27
 Thinking about
Binary Search Trees
Observations
 Each operation views two new elements at a time
 Elements (even siblings) may be scattered in
memory
 Binary search trees are fast if they’re shallow

Realities
 For large data sets, disk accesses dominate runtime
 Some deep and some shallow BSTs exist for any data

Binary Search CSE 326 Autumn 2001

Trees 28
 Beauty is Only (log n)
Deep
Binary Search Trees are fast if they’re shallow:
 perfectly complete
 complete – possibly missing some “fringe” (leaves)
 any other good cases?

What matters?
 Problems occur when one branch is much longer than
another
 i.e. when tree is out of balance

Binary Search CSE 326 Autumn 2001

Trees 29
 Dictionary
Implementations
unsorted sorted linked BST
array array list
inser O(n) find + O(1) O(Dept
t O(n) h)
find O(n) O(log n) O(n) O(Dept
h)
delet find + find + find + O(Dept
e O(1) O(1) O(1) h)
(mark-as- (mark-as-
deleted) deleted)
BST’s looking good for shallow trees, i.e. if Depth is
small (log n); otherwise as bad as a linked list!
Binary Search CSE 326 Autumn 2001
Trees 30
 Digression: Tail Recursion
 Tail recursion: when the tail (final
operation) of a function recursively calls
the function

 Why is tail recursion especially bad with

a linked list?

 Why might it be a lot better with a tree?

Why might it not?

Binary Search CSE 326 Autumn 2001

Trees 31
 Making Trees Efficient:
Possible Solutions
Keep BSTs shallow by maintaining
“balance”
AVL trees

… also exploit most-recently-used (mru) info

Splay trees

Reduce disk access by increasing branching

factor
B-trees
Binary Search CSE 326 Autumn 2001
Trees 32