C++ 模板函数 二分查找

C++ 模板函数 二分查找

• 简单二分查找
• 使用模板函数实现二分查找
• 接收函数指针作为比较函数
• 进一步优化

---

简单二分查找

二分查找也称对半查找，是一种很常用的，高效率的搜索算法，时间复杂度为O(log N)。该算法假定要查找的数据已经升序排序完毕。算法的思路比较简单，在这里主要是作为一个C++模板函数的一次练习。
下面是百度百科上对二分查找查找过程的介绍，忘记了的同学可以看看。

首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

先是简单的C++代码实现，最简单，常见的查找是对一个int数组进行查找：

int BinarySearch(const int arr[], const int &target, int array_size) {
	int low, height, mid;
	
	low = 0;
	height = array_size - 1;

	while (low <= height) {
		mid = (low + height) / 2;
		if (arr[mid] < target)
			low = mid + 1;
		else if (arr[mid] > target)
			height = mid - 1;
		else
			return mid;
	}

	return -1;
}

使用模板函数实现二分查找

上面的代码实现了二分查找，但是存在一个问题是，该函数只能对int数组进行查找，其他类型无法调用该函数，如果我们有一个double数组，就需要再写一个几乎一模一样的函数。
对每种类型都需要写一个这样的函数无疑是很麻烦的，因此，使用C++的模板来解决这个问题

template<class T> int BinarySearch(const T arr[], const T &target, int array_size) {
	int low, height, mid;
	
	low = 0;
	height = array_size - 1;

	while (low <= height) {
		mid = (low + height) / 2;
		if (arr[mid] < target)
			low = mid + 1;
		else if (arr[mid] > target)
			height = mid - 1;
		else
			return mid;
	}

	return -1;
}

将接受的数组和要查找的目标的参数类型用模板表示，该函数可以接受多种类型的参数。

接收函数指针作为比较函数

使用模板函数改造之后，我们的二分查找算法可以接受多种类型的参数，就不需要为每个类型写一个对应的二分查找算法，但是该函数还有一个问题：并不是每个类型都有"<“运算。我们自定义的类型很有可能没有重载”<“运算符，而且，有时候，对于特定的应用场景，可能重载的”<"运算符并不符合我们的需求，因此，我们的二次查找算法应该要能接收一个用户自定义的比较函数，使用该比较函数来进行查找。

template<class T> 
int BinarySearch(const T elements[], const T &target, 
	int length, bool(*less)(const T &a, const T &b)) {
	size_t low, mid, height;
	low = 0;
	height = length - 1;


	while (low <= height) {
		mid = (low + height) / 2;

		if (less(elements[mid], target)) {
			low = mid + 1;
		} else if (less(target, elements[mid])) {
			height = mid - 1;
		} else {
			return mid;
		}
	}

	return -1;
}

进一步优化

上面的函数基本就可以接收任意类型，并且可以接收自定义的比较函数。但是还有几个小问题。
上面的函数里有一个参数：length用来表示数组的长度，可以通过在函数内部计算数组的长度来降低调用的负担：

size_t length = sizeof(elements) / sizeof(elements[0]);

另一个问题是，上面的代码相当于有两个函数：

template<class T> int BinarySearch(const T arr[], const T &target, int array_size);
template<class T> int BinarySearch(const T elements[], const T &target, 
	int length, bool(*less)(const T &a, const T &b));

C++会根据调用的参数个数来匹配调用那个函数，这个没什么问题，问题在于，这两个函数中的代码基本相似，如果以后要修改的话（如第一个问题说的将数组的长度交由函数计算），很可能需要同时对两个函数都进行修改，否则会导致两个函数表现出不同的行为，这显然是不好的结果，因此，将两个函数改造为：

template<class T> bool default_compare(const T &a, const T &b) {
	return a < b;
}

template<class T> int BinarySearch(const T elements[], const T &target, bool(*less)(const T &a, const T &b)) {
	size_t low, mid, height;
	size_t length = sizeof(elements) / sizeof(elements[0]);

	low = 0;
	height = length - 1;


	while (low <= height) {
		mid = (low + height) / 2;

		if (less(elements[mid], target)) {
			low = mid + 1;
		} else if (less(target, elements[mid])) {
			height = mid - 1;
		} else {
			return mid;
		}
	}

	return -1;
}

template<class T> int BinarySearch(const T elements[], const T &target) {

	bool(*less)(const T &a, const T&b) = default_compare<T>;

	return BinarySearch(elements, target, less);
}

但是上面代码增加了函数调用的开销，所以就有了下面的代码：

template<class T> int BinarySearch(const T elements[], const T &target, bool(*less)(const T &a, const T &b) = nullptr) {
	int low, mid, height;
	int length = sizeof(elements) / sizeof(elements[0]);

	low = 0;
	height = length - 1;

	if (less != nullptr) {
		while (low <= height) {
			mid = (low + height) / 2;

			if (less(elements[mid], target)) {
				low = mid + 1;
			} else if (less(target, elements[mid])) {
				height = mid - 1;
			} else {
				return mid;
			}
		}
	} else {
		while (low <= height) {
			mid = (low + height) / 2;

			if (elements[mid] < target) {
				low = mid + 1;
			} else if (target < elements[mid]) {
				height = mid - 1;
			} else {
				return mid;
			}
		}
	}

	return -1;
}

但是代码看起来又有很多的重复…
所以需要在优雅的代码的效率之间权衡吗，哪位大佬有解决的方法，告诉一下本菜鸟，万分感谢！！！