6.1 Searching Algorithms: Linear Search and Binary Search

What this competency asks

ETS groups searching with sorting: understand searching and sorting algorithms; analyze searching algorithms for correctness and efficiency. For searching, you should be able to:

1. Trace algorithms and predict output and intermediate results.
2. Calculate the number of comparisons required for linear and binary search.

Linear (sequential) search

Linear search checks each element in order until it finds the target or runs out of elements.

// returns the index of target in list, or -1 if it is absent
int linearSearch ( int[ ] list, int n, int target )
    for ( int i ← 0; i < n; i ← i + 1 )
        if ( list[i] == target )
            return i
        end if
    end for
    return -1
end linearSearch

Linear search is O(n). It needs no precondition: the data may be unsorted, and it works on structures that can only be walked in order, such as linked lists. If the list is known to be sorted, you can stop early once an element exceeds the target. That shortens unsuccessful searches, but the worst case is still O(n).

Binary search

Binary search works only on sorted data. It compares the target with the middle element of the current range and discards the half that cannot contain the target.

// list is sorted in increasing order; first element at index 0
int binarySearch ( int[ ] list, int n, int target )
    int low ← 0
    int high ← n - 1
    while ( low ≤ high )
        int mid ← ( low + high ) / 2       // integer division
        if ( list[mid] == target )
            return mid
        else
            if ( list[mid] < target )
                low ← mid + 1
            else
                high ← mid - 1
            end if
        end if
    end while
    return -1
end binarySearch

Worked trace

Sorted list (indexes 0–9): {3, 8, 12, 17, 23, 31, 38, 44, 50, 61}

Search for 44

Two elements examined: 23 and 44.

Search for 20 (absent)

Four elements examined: 23, 8, 12, 17. For n = 10, the maximum is ⌊log₂ 10⌋ + 1 = 3 + 1 = 4.

Counting comparisons

Each pass through the loop examines one element and at least halves the remaining range, so binary search examines at most ⌊log₂ n⌋ + 1 elements. This equals ⌈log₂(n + 1)⌉.

A quick way to calculate: find the smallest power of 2 that is greater than n, and use its exponent. For n = 1,000,000: 2¹⁹ = 524,288 ≤ n and 2²⁰ = 1,048,576 > n, so the maximum is 20. For exactly n = 16, 2⁴ = 16 is not greater than 16, so the maximum is 5.

Some questions count three-way comparisons ("equal, less, or greater?") as one comparison, as above. Others count each == and < test separately. Read the stem's definition.

Correctness details

• Precondition: sorted data. On unsorted data, binary search can report that a present value is missing.
• Loop condition low ≤ high. When low equals high, one element remains and must still be checked. Using < skips it.
• Bounds mid + 1 and mid - 1. The middle element was already checked. Setting low ← mid can cause an infinite loop when high = low + 1.
• Duplicates. Standard binary search returns some matching index, not necessarily the first. Finding the first occurrence requires continuing to search the left half after a match.
• Integer overflow. In languages with fixed-size integers, ( low + high ) / 2 can overflow for enormous arrays. low + ( high - low ) / 2 gives the same midpoint without the risk.

Choosing between them

If the data are unsorted and you will search once, use linear search. Sorting first costs O(n log n), which is more than the O(n) search. If you will search many times, sort once and then use binary search. The sorting cost is spread across all the fast searches.