【基础算法补全】二分查找

算法思想：

在一个无序的顺序存储结构中，要想寻找到某一个元素，我们通常需要对该结构中的元素逐个遍历。这非常耗费时间。但在有序数组中，我们有比逐个比对更为快捷的算法可供选择——如果我们能够利用数组有序的性质，选择性的遍历数组的部分，那么程序的执行便会有效率得多了。

以升序序列为例。在一个升序数组中，一个数左边的数必定是小于该数的，而其右边的数必定是大于该数的。于是，在接下来的搜索中，我们可以每次都只对比数组的中间项与待查找值是否一致，并把该数组沿中间项“切开”分为两半，根据中间项与待查找值的对比结果来选择在元素数值均比中间项小的左半边亦或是元素数值均比中间项大的右半边重复执行上述操作，直到找到目标值——或者数组无法继续切分为止。

值得注意的是：

                         -代码中循环的继续条件是需要根据查找区间的开闭来进行选择的，如果是开区间查找，则为“max > min”，若是闭区间查找，则为“max >= min”;

代码实现：

C++代码实现：

非递归算法：

int findTarget(int *arr,int length,int target){
    int idx = -1;
    int mid,max = length - 1,min = 0;
    // while(max > min){ // 左开右开区间
    while(max >= min){ // 左开右闭、左闭右闭、左闭右开区间
        mid = min + ((max - min) >> 1);
        if(arr[mid] == target){
            idx = mid;
            break;
        }else if(arr[mid] < target){
            min = mid + 1;
        }else if(arr[mid] > target){
            max = mid - 1;
        }
    }
    return idx;
}

递归实现：

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

Golang代码实现：

非递归实现：

func findTarget(nums []int,target int) int{
	var idx = -1
	min,max := 0,len(nums) - 1
	for min <= max{
		mid := min + ((max - min) >> 1)
		if nums[mid] == target{
			idx = mid
			break
		}else if nums[mid] > target{
			max = mid - 1
		}else if nums[mid] < target{
			min = mid + 1
		}
	}
	return idx
}

递归实现：

func findTarget(nums []int,target int,left int,right int) int{
	if left > right{
		return -1
	}
	mid := left + ((right - left) >> 1)
	if nums[mid] == target{
		return mid
	}else if nums[mid] < target{
		return findTarget(nums,target,mid + 1,right)
	}else if nums[mid] > target{
		return findTarget(nums,target,left,mid - 1)
	}
	return -1
}