Chapter 10: Search Trees
Objectives:
Binary Search Trees: Search, update,
and implementation
AVL Trees: Properties and maintenance
2-4 Trees: Properties and maintenance
Red-black Trees: Properties and
equivalence to 2-4 Trees
CSC311: Data Structures
1
Ordered Dictionaries
Keys are assumed to come from a total
order.
New operations:
– first(): first entry in the dictionary ordering
– last(): last entry in the dictionary ordering
– successors(k): iterator of entries with keys
greater than or equal to k; increasing order
– predecessors(k): iterator of entries with keys
less than or equal to k; decreasing order
Search Trees
CSC311: Data Structures
2
Binary Search
Binary search can perform operation find(k) on a
dictionary implemented by means of an array-based
sequence, sorted by key
– similar to the high-low game
– at each step, the number of candidate items is halved
– terminates after O(log n) steps
Example: find(7)
0
1
3
4
5
7
1
0
3
4
5
m
l
0
9
11
14
16
18
m
l
0
8
1
1
3
3
7
19
h
8
9
11
14
16
18
19
8
9
11
14
16
18
19
8
9
11
14
16
18
19
h
4
5
7
l
m
h
4
5
7
l=m =h
Search Trees
CSC311: Data Structures
3
Search Tables
A search table is a dictionary implemented by
means of a sorted sequence
– We store the items of the dictionary in an array-based
sequence, sorted by key
– We use an external comparator for the keys
Performance:
– find takes O(log n) time, using binary search
– insert takes O(n) time since in the worst case we have to
shift n/2 items to make room for the new item
– remove take O(n) time since in the worst case we have
to shift n/2 items to compact the items after the removal
The lookup table is effective only for dictionaries
of small size or for dictionaries on which searches
are the most common operations, while
insertions and removals are rarely performed
(e.g., credit card authorizations)
Search Trees
CSC311: Data Structures
4
Binary Search Trees
A binary search tree is
a binary tree storing
keys (or key-value
entries) at its internal
nodes and satisfying
the following property:
– Let u, v, and w be three
nodes such that u is in
the left subtree of v and
w is in the right subtree
of v. We have
key(u)  key(v)  key(w)
An inorder traversal
of a binary search
trees visits the keys
in increasing order
6
2
1
9
4
8
External nodes do not
store items
Search Trees
CSC311: Data Structures
5
Search
To search for a key k,
we trace a downward
path starting at the root
The next node visited
depends on the
outcome of the
comparison of k with
the key of the current
node
If we reach a leaf, the
key is not found and we
return nukk
Example: find(4):
Algorithm TreeSearch(k, v)
if T.isExternal (v)
return v
if k < key(v)
return TreeSearch(k, T.left(v))
else if k = key(v)
return v
else { k > key(v) }
return TreeSearch(k, T.right(v))
<
2
– Call TreeSearch(4,root)
1
Search Trees
CSC311: Data Structures
6
9
>
4 =
8
6
Insertion
To perform operation
inser(k, o), we search
for key k (using
TreeSearch)
Assume k is not already
in the tree, and let let w
be the leaf reached by
the search
We insert k at node w
and expand w into an
internal node
Example: insert 5
Search Trees
6
<
2
9
>
1
4
8
>
w
6
2
1
CSC311: Data Structures
9
4
8
w
5
7
Deletion
To perform operation
remove(k), we search for
key k
Assume key k is in the
tree, and let v be the
node storing k
If node v has a leaf child
w, we remove v and w
from the tree with
operation
removeExternal(w),
which removes w and its
parent
Example: remove 4
Search Trees
6
<
2
9
>
4 v
1
8
w
5
6
2
1
CSC311: Data Structures
9
5
8
8
Deletion (cont.)
We consider the case where
the key k to be removed is
stored at a node v whose
children are both internal
– we find the internal node w
that follows v in an inorder
traversal
– we copy key(w) into node v
– we remove node w and its
left child z (which must be
a leaf) by means of
operation
removeExternal(z)
1
v
3
2
6
w
9
5
z
1
Example: remove 3
Search Trees
8
CSC311: Data Structures
v
5
2
8
6
9
9
Performance
Consider a
dictionary with n
items implemented
by means of a
binary search tree of
height h
– the space used is O(n)
– methods find, insert
and remove take O(h)
time
The height h is O(n)
in the worst case
and O(log n) in the
best case
Search Trees
CSC311: Data Structures
10
AVL Tree Definition
4
AVL trees are
44
balanced.
2
3
17
78
An AVL Tree is a
1
2
1
88
binary search
32
50
1
1
tree such that for
48
62
every internal node
v of T, the heights
of the children of v
An example of an AVL tree where
can differ by at
the heights are shown next to the
most 1.
nodes.
Search Trees
CSC311: Data Structures
11
Height of an AVL Tree
Fact: The height of an AVL tree storing n keys is
O(log n).
Proof: Let us bound n(h): the minimum number of
internal nodes of an AVL tree of height h.
We easily see that n(1) = 1 and n(2) = 2
For n > 2, an AVL tree of height h contains the root
node, one AVL subtree of height n-1 and another of
height n-2.
That is, n(h) = 1 + n(h-1) + n(h-2)
Knowing n(h-1) > n(h-2), we get n(h) > 2n(h-2). So
n(h) > 2n(h-2), n(h) > 4n(h-4), n(h) > 8n(n-6), … (by
induction),
n(h) > 2in(h-2i)
Solving the base case we get: n(h) > 2 h/2-1
Taking logarithms: h < 2log n(h) +2
Thus the height of an AVL tree is O(log n)
Search Trees
CSC311: Data Structures
12
Insertion in an AVL Tree
Insertion is as in a binary search tree
Always done by expanding an external node.
Example:
44
44
17
78
17
78
c=z
a=y
32
50
48
88
62
32
50
88
48
62
b=x
54
w
before insertion
Search Trees
CSC311: Data Structures
after insertion
13
Trinode Restructuring
let (a,b,c) be an inorder listing of x, y, z
perform the rotations needed to make b the topmost node
of the three
(other two cases
are symmetrical)
a=z
a=z
case 2: double rotation
(a right rotation about c,
then a left rotation about a)
c=y
b=y
T0
T0
b=x
c=x
T1
T3
b=y
T2
T1
T3
a=z
b=x
T2
c=x
a=z
c=y
case 1: single rotation
(a left rotation about a)
T0
Search Trees
T1
T2
T3
CSC311: Data Structures
T0
T1
T2
T3
14
Insertion Example, continued
44
2
5
z
17
32
3
1
1
1
1
50
2
1
7
78
2y
48
64
3
4
62
88
x
5
T3
54
unbalanced...
T2
T0
T1
44
2
4
3
17
32
1
1
...balanced
1
48
2 y
2
50
4
x
z6
62
3
1
5
78
54
2
7
1
88
T2
T0
Search Trees
CSC311: Data Structures
T1
T3
15
Restructuring: Single Rotations
Single Rotations:
a=z
single rotation
b=y
c=x
T0
T1
T3
T2
c =z
a=z
T0
single rotation
b=y
b=y
c=x
T1
T3
T2
b=y
a=x
c =z
a=x
T0
Search Trees
T1
T2
T3
T3
CSC311: Data Structures
T2
T1
T0
16
Restructuring: Double Rotations
double rotations:
double rotation
a=z
c= y
b=x
a=z
c= y
b=x
T0
T1
T3
T2
T0
T1
double rotation
c=z
a=y
T2
T3
b=x
a=y
c=z
b=x
T3
Search Trees
T2
T0
T3
T2
T1
T0
T1
CSC311: Data Structures
17
Removal in an AVL Tree
Removal begins as in a binary search tree,
which means the node removed will become an
empty external node. Its parent, w, may cause
an imbalance.
Example:
44
44
17
62
32
50
48
17
78
54
50
88
before deletion of 32
Search Trees
62
CSC311: Data Structures
48
78
54
88
after deletion
18
Rebalancing after Removal
Let z be the first unbalanced node encountered while
travelling up the tree from w. Also, let y be the child of z
with the larger height, and let x be the child of y with the
larger height.
We perform restructure(x) to restore balance at z.
As this restructuring may upset the balance of another
node higher in the tree, we must continue checking for
balance until the root of T is reached
a=z
w
62
44
17
50
48
Search Trees
c=x
78
54
44
b=y
62
17
50
48
88
CSC311: Data Structures
78
88
54
19
Running Times for AVL Trees
a single restructure is O(1)
– using a linked-structure binary tree
find is O(log n)
– height of tree is O(log n), no restructures needed
insert is O(log n)
– initial find is O(log n)
– Restructuring up the tree, maintaining heights is O(log n)
remove is O(log n)
– initial find is O(log n)
– Restructuring up the tree, maintaining heights is O(log n)
Search Trees
CSC311: Data Structures
20