Note: Please refer to the "Searching" SparkNote if you have not learned about the
linear search (click
here) and
binary search (click here). Only a brief
review will be offered here.

Searching, one of the most fundamental problems in computer science, is well
accomplished with recursive techniques. We will look at two algorithms for
searching: linear search and binary search.

Linear search operates by looking sequentially through data, comparing the
current element to the search element. If they are the same, the search has
found what it's looking for. If they're different, it moves on to the next
data element and repeats. If after all the data has been examined the
search element has not been found, it does not exist in the data being
searched.

Thinking about this from a recursive standpoint, we compare the first
element to the search element. If they're the same, great. Otherwise,
we return whether the search element exists in the rest of the string.
Linear search can work on any type of data. Since we just finished
looking at strings, we'll use characters as our data type

int linear_search(char search[], char find, int n)
{
int i;
for(i=0; i<n; i++) if (search[i] == find) return i;
return -1;
}

Easy, right? Let's move onto binary search.

Binary search is an inherently recursive algorithm: we can implement
iteratively, but it makes more sense algorithmicly to do it recursively
(though for certain implementations you might choose to do it iteratively
for efficiency reasons). Binary search works by splitting up a sorted
data set into two parts. We examine the data element at the split to see
which side the data we're searching for would be in. Once we know which
side the data would be in, we can eliminate all of the data elements in the
other half. Then we repeat the process with our smaller data set. Each
time we repeat, we throw away half of the data; this makes for a relatively
efficient search (*O*(*log*(*n*))).

Let's search a sorted array of integers. We'll return the index into the
array where the searched for data exists, or an invalid index if the data
isn't found.

int binary_search(int arr[], int find, int low, int high)
{
int middle = (low + high)/2;
if (start > finish) return -1;
if (arr[middle] < find) return binary_search(arr, find, middle, high);
else if (arr[middle] > find) return binary_search(arr, find, low, middle);
else return middle;
}

Of course, binary search can be done iteratively as mentioned:

int binary_search(int arr[], int find, int low, int high)
{
int middle;
while(low <= high) {
middle = (low + high) / 2;
if (arr[middle] < find) low = middle;
else if (arr[middle] > find) high = middle;
else return middle;
}
return -1;
}

But intuitively it makes more sense recursively.