Binary Search in Trees

We will provide two solutions, one iterative and one recursive. The return value from both is the index in the original array. If the element is not present in the array, the sharp-defined value ~NOT_FOUND~ is returned.

int bin_search (int arr[], int n, int val)
{
	/* n indicates the number of cells in the array */

	int low, high, mid;

	low = 0;

	/* Set high to be the highest array index. */ 
	high = n - 1;

	while (high >= low) {

		/* Begin searching in the middle */
		mid = (low + high) / 2;

		/* Check if you have found it or adjust the range accordingly */
		if (arr[mid] == val) {
			return mid;
		} else if (arr[mid] > val) {
			high = mid - 1;
		} else {
			low = mid + 1;
		}
	}

	return NOT_FOUND;
}

Now for the recursive one. The basic idea it that it keeps applying the same algorithm on the reduced range. The tricky part is offsetting the return value.

int bin_search (int arr[], int n, int val)
{
	int mid;

	if (n == 0) return NOT_FOUND;

	if (n == 1) return (arr[0] == val? 0 : NOT_FOUND);

	mid = (n - 1) / 2;

	/* Check if you have found it or adjust the range accordingly */
	if (arr[mid] == val) {
		return mid;
	} else if (arr[mid] > val) {
		return mid + bin_search (&arr[mid + 1], n / 2, val);
	} else {
		return mid + bin_search (&arr[mid - 1], (n - 1) / 2, val);
	}
}

In order to check for duplicates, it suffices to check if the root of the right subtree has the same data element as the parent.

int	duplicates (tree_t *t)
{
	if (t == NULL) return 0;

	if (t->right == NULL) return 0;

	if (t->data == t->right)
		return 1;
	else
		return duplicates(t->left) || duplicates(t->right);
}

The worst case for searching is basically one where the binary search tree provides no help in dividing up the data. In other words, it is the case where the tree branches exclusively in one direction. In this case if there are n nodes in the tree, then there is one leaf and it is at depth n - 1. Thus a search in this tree consists of walking through each data element in order until you find the one you want. Hence, the complexity is O(n) . Similarly, adding a new data element means walking along each data element until you find the place to add it; this is also O(n) .