Algorithms

3.1 ■ Symbol Tables
383
Analysis of binary search The recursive implementation of rank() also leads
to an immediate argument that binary search guarantees fast search, because it corresponds
to a recurrence relation that describes an upper bound on the number of
compares.
Propos i t i o n B. Binary search in an ordered array with N keys uses no more than
lg N 1 compares for a search (successful or unsuccessful).
Proof: This analysis is similar to (but simpler than) the analysis of mergesort
(Proposition F in Chapter 2). Let C(N) be the number of compares needed to
search for a key in a symbol table of size N. We have C(0) = 0, C(1) = 1, and for N >
0 we can write a recurrence relationship that directly mirrors the recursive method:
C(N ) C(⎣N/2⎦) 1
Whether the search goes to the left or to the right, the size of the subarray is no
more than ⎣N/2⎦, and we use one compare to check for equality and to choose
whether to go left or right. When N is one less than a power of 2 (say N = 2 n 1),
this recurrence is not difficult to solve. First, since ⎣N/2⎦ = 2 n 1 1, we have
C(2 n 1) C(2 n 1 1) 1
Applying the same equation to the first term on the right, we have
C(2 n 1) C(2 n 2 1) 1 1
Repeating the previous step n 2 additional times gives
which leaves us with the solution
C(2 n 1) C(2 0 ) n
C(N ) = C(2 n ) n 1 < lg N 1
Exact solutions for general N are more complicated, but it is not difficult to extend
this argument to establish the stated property for all values of N (see Exercise
3.1.20). With binary search, we achieve a logarithmic-time search guarantee.
The implementation just given for ceiling() is based on a single call to rank(), and
the default two-argument size() implementation calls rank() twice, so this proof also
establishes that these operations (and floor()) are supported in guaranteed logarithmic
time (min(), max(), and select() are constant-time operations).