Algorithms and Data Structures

N.Wirth. Algorithms and Data Structures. Oberon version 35
1.8 Searching
The task of searching is one of most frequent operations in computer programming. It also provides an
ideal ground for application of the data structures so far encountered. There exist several basic variations of
the theme of searching, and many different algorithms have been developed on this subject. The basic
assumption in the following presentations is that the collection of data, among which a given element is to
be searched, is fixed. We shall assume that this set of N elements is represented as an array, say as
a: ARRAY N OF Item
Typically, the type item has a record structure with a field that acts as a key. The task then consists of
finding an element of a whose key field is equal to a given search argument x. The resulting index i,
satisfying a[i].key = x, then permits access to the other fields of the located element. Since we are here
interested in the task of searching only, and do not care about the data for which the element was searched
in the first place, we shall assume that the type Item consists of the key only, i.e is the key.
1.8.1 Linear Search
When no further information is given about the searched data, the obvious approach is to proceed
sequentially through the array in order to increase step by step the size of the section, where the desired
element is known not to exist. This approach is called linear search. There are two conditions which
terminate the search:
1. The element is found, i.e. a i = x.
2. The entire array has been scanned, and no match was found.
This results in the following algorithm:
i := 0; (* ADenS18_Search *)
WHILE (i < N) & (a[i] # x) DO INC(i) END
Note that the order of the terms in the Boolean expression is relevant.
The invariant, i.e the condition satisfied before and after each loop step, is
(0 ≤ i < N) & (Ak: 0 ≤ k < i : a k ≠ x)
expressing that for all values of k less than i no match exists. Note that the values of i before and after each
loop step are different. The invariant is preserved nevertheless due to the while-clause.
From this and the fact that the search terminates only if the condition in the while-clause is false, the
resulting condition is derived as:
((i = N) OR (a i = x )) & (Ak: 0 ≤ k < i : a k ≠ x)
This condition not only is our desired result, but also implies that when the algorithm did find a match, it
found the one with the least index, i.e. the first one. i = N implies that no match exists.
Termination of the repetition is evidently guaranteed, because in each step i is increased and therefore
certainly will reach the limit N after a finite number of steps; in fact, after N steps, if no match exists.
Each step evidently requires the incrementing of the index and the evaluation of a Boolean expression.
Could this task be simplifed, and could the search thereby be accelerated? The only possibility lies in
finding a simplification of the Boolean expression which notably consists of two factors. Hence, the only
chance for finding a simpler solution lies in establishing a condition consisting of a single factor that implies
both factors. This is possible only by guaranteeing that a match will be found, and is achieved by posting an
additional element with value x at the end of the array. We call this auxiliary element a sentinel, because it
prevents the search from passing beyond the index limit. The array a is now declared as