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.