对二分法查找、归并排序、快排做下代码总结：

参考

//二分查找非递归

int binary_find(int *arr, int left, int right, int element_find) {

	while (left <= right)
	{
		//int mid = (left + right) / 2; //left + right 可能溢出 
		int mid = left + ((right - left) >> 1);

		if (arr[mid]>element_find)
		{
			right = mid - 1;
		}
		else if (arr[mid]<element_find)
		{
			left = mid + 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;
}

//二分查找，递归

int binary_find(int *arr, int left, int right, int element_find) {
	if (left > right)
		return -1;
	int mid = left + ((right - left) >> 1);
	if (arr[mid] == element_find)
		return mid;
	else if (arr[mid] > element_find)
		return binary_find(arr, left, mid - 1, element_find);
	else
		return binary_find(arr, mid + 1, right, element_find);
}

//归并排序 递归

void merge(int *arr1, int len1, int *arr2, int len2) {

	int l1, l2, k;
	l1 = l2 = k = 0;
	int *tmp = new int[len1 + len2];

	while (l1 < len1 && l2 < len2) {
		
		if (arr1[l1] < arr2[l2])
			tmp[k++] = arr1[l1++];
		else
			tmp[k++] = arr2[l2++];
	}
	while (l1 < len1) {
		tmp[k++] = arr1[l1++];
	}
	while (l2 < len2) {
		tmp[k++] = arr2[l2++];
	}
	memcpy(arr1,tmp,(len1 + len2) * sizeof(int));

	delete[]tmp;
}

void mergeSort(int *arr, int len) {

	if (len > 1) {
		
		int len1 = len / 2;
		int len2 = len - len / 2;
		mergeSort(arr, len1);
		mergeSort(arr + len1, len2);
		merge(arr, len1, arr + len1, len2);

	}

}

//归并 非递归

//归并 非递归
void MergeSort(int k[], int n)
{
	int i, next, left_min, left_max, right_min, right_max;
	//开辟一个与原来数组一样大小的空间用来存储用  
	int *temp = (int *)malloc(n * sizeof(int));
	//逐级上升，第一次比较2个，第二次比较4个，第三次比较8个。。。  
	for (i = 1; i<n; i *= 2)
	{
		//每次都从0开始，数组的头元素开始  
		for (left_min = 0; left_min<n - i; left_min = right_max)
		{
			right_min = left_max = left_min + i;
			right_max = left_max + i;
			//右边的下标最大值只能为n  
			if (right_max>n)
			{
				right_max = n;
			}
			//next是用来标志temp数组下标的，由于每次数据都有返回到K，  
			//故每次开始得重新置零  
			next = 0;
			//如果左边的数据还没达到分割线且右边的数组没到达分割线，开始循环  
			while (left_min<left_max&&right_min<right_max)
			{
				if (k[left_min] < k[right_min])
				{
					temp[next++] = k[left_min++];

				}
				else
				{
					temp[next++] = k[right_min++];
				}
			}
			//上面循环结束的条件有两个，如果是左边的游标尚未到达，那么需要把  
			//数组接回去，可能会有疑问，那如果右边的没到达呢，其实模拟一下就可以  
			//知道，如果右边没到达，那么说明右边的数据比较大，这时也就不用移动位置了  

			while (left_min < left_max)
			{
				//如果left_min小于left_max，说明现在左边的数据比较大  
				//直接把它们接到数组的min之前就行  
				k[--right_min] = k[--left_max];
			}
			while (next>0)
			{
				//把排好序的那部分数组返回该k  
				k[--right_min] = temp[--next];
			}
		}
	}
}

//快速排序

void quickSort(int *arr, int start, int end) {
			
	if (arr == NULL || start >= end)
		return;

	int key = arr[start];
	int l = start;
	int r = end;
	while (l < r) {

		while (l < r && key <= arr[r]) {
			r--;
		}
		if (l < r)
			arr[l++] = arr[r];

		while (l < r && key >= arr[l]) {
			l++;
		}
		if (l < r)
			arr[r--] = arr[l];
	}
	arr[l] = key;
	quickSort(arr,start,l-1);
	quickSort(arr,l+1,end);

}    

//快排写法2

void quickSort2(int *arr, int start, int end) {

	if (arr == NULL || start >= end)
		return;

	int key = arr[start];
	int l = start;
	int r = end;
	while (l < r) {

		while (l < r && key <= arr[r]) {
			r--;
		}

		while (l < r && key >= arr[l]) {
			l++;
		}
		if (l < r) {
			int tmp = arr[l];
			arr[l] = arr[r];
			arr[r] = tmp;
		}
	}
	arr[start] = arr[l];//j先走，不用判断最后中间数和基准数大小，直接换就可以。具体举例
	arr[l] = key;
	quickSort(arr, start, l - 1);
	quickSort(arr, l + 1, end);

}

快排2参考