Algorithms and Data Structures

N.Wirth. Algorithms and Data Structures. Oberon version 37
as possible from further searches, no matter what the outcome of the comparison is. The optimal solution is
to choose the middle element, because this eliminates half of the array in any case. As a result, the
maximum number of steps is log 2 N, rounded up to the nearest integer. Hence, this algorithm offers a drastic
improvement over linear search, where the expected number of comparisons is N/2.
The efficiency can be somewhat improved by interchanging the two if-clauses. Equality should be tested
second, because it occurs only once and causes termination. But more relevant is the question, whether —
as in the case of linear search — a solution could be found that allows a simpler condition for termination.
We indeed find such a faster algorithm, if we abandon the naive wish to terminate the search as soon as a
match is established. This seems unwise at first glance, but on closer inspection we realize that the gain in
efficiency at every step is greater than the loss incurred in comparing a few extra elements. Remember that
the number of steps is at most log N.
The faster solution is based on the following invariant:
(Ak: 0 ≤ k < L : a k < x) & (Ak: R ≤ k < N : a k ≥ x)
and the search is continued until the two sections span the entire array.
L := 0; R := N; (* ADenS18_Search *)
WHILE L < R DO
m := (L+R) DIV 2;
IF a[m] < x THEN L := m+1 ELSE R := m END
END
The terminating condition is L ≥ R. Is it guaranteed to be reached? In order to establish this guarantee,
we must show that under all circumstances the difference R-L is diminished in each step. L < R holds at the
beginning of each step. The arithmetic mean m then satisfies L ≤ m < R. Hence, the difference is indeed
diminished by either assigning m+1 to L (increasing L) or m to R (decreasing R), and the repetition
terminates with L = R.
However, the invariant and L = R do not yet establish a match. Certainly, if R = N, no match exists.
Otherwise we must take into consideration that the element a[R] had never been compared. Hence, an
additional test for equality a[R] = x is necessary. In contrast to the first solution, this algorithm — like
linear search — finds the matching element with the least index.
1.8.3 Table Search
A search through an array is sometimes also called a table search, particularly if the keys are
themselves structured objects, such as arrays of numbers or characters. The latter is a frequently
encountered case; the character arrays are called strings or words. Let us define a type String as
String
= ARRAY M OF CHAR
and let order on strings x and y be defined as follows:
(x = y) ≡ (Aj: 0 ≤ j < M : x j = y j )
(x < y) ≡ Ei: 0 ≤ i < N : ((Aj: 0 ≤ j < i : x j = y j ) & (x i < y i ))
In order to establish a match, we evidently must find all characters of the comparands to be equal. Such a
comparison of structured operands therefore turns out to be a search for an unequal pair of comparands,
i.e. a search for inequality. If no unequal pair exists, equality is established. Assuming that the length of the
words be quite small, say less than 30, we shall use a linear search in the following solution.
In most practical applications, one wishes to consider strings as having a variable length. This is
accomplished by associating a length indication with each individual string value. Using the type declared
above, this length must not exceed the maximum length M. This scheme allows for sufficient flexibility for
many cases, yet avoids the complexities of dynamic storage allocation. Two representations of string