對二分法查詢、歸併排序、快排做下程式碼總結：

參考

//二分查詢非遞迴

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);

}