二分的一些东西 (一)

最原始二分

单调有序且没有重复元素，而且要在数组里，进行查找

当 target在数组中时

int binarySearch(int[] nums,int target,int left, int right){
    while (left <= right) {										// 这里 注意是 <=
        int mid = left + ((right - left) >> 1);				// 防止 (L+R)溢出
        if (nums[mid] == target) {
            return mid;
        }else if (nums[mid] < target) {
            left  = mid + 1;
        }else {        
            right = mid - 1;
        }
    }
    //没有找到该元素,返回 -1
    return -1;
}

递归写法：

int select(int arr[],int left,int right,int target){
	if(left>right)return -1;		// 没找到 
	int mid=left+(right-left)/2;
	if(arr[mid]==target){
		return mid;
	}else if(arr[mid]>target){
		select(arr,left,mid-1,target);
	}else{
		select(arr,mid+1,right,target);
	}
}

当 target不在数组中时

• left 和 right都指向同一元素时，本次将是循环体内最后一次。
  
• left和right相邻时，本次有可能是最后一次，也有可能还能进行一次。
  
• left和right隔了一个元素时
  
• left和right隔了两个元素时
  
  综上，最后一次只有两种情况。
• left和right指向同一元素
• left和right相邻，且target<left=mid

分析完之后，我们再来看

leetcode35 搜索插入位置

---

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。

---

示例 1:
输入: [1,3,5,6], 5
输出: 2

示例 2:
输入: [1,3,5,6], 2
输出: 1

示例 3:
输入: [1,3,5,6], 7
输出: 4

示例 4:
输入: [1,3,5,6], 0
输出: 0

---

int binarySearch(int[] nums,int target,int left, int right){
    while (left <= right) {										// 这里 注意是 <=
        int mid = left + ((right - left) >> 1);				// 防止 (L+R)溢出
        if (nums[mid] == target) {
            return mid;
        }else if (nums[mid] < target) {
            left  = mid + 1;
        }else {        
            right = mid - 1;
        }
    }
    //没有找到该元素, 返回 插入位置
    return left;						// 这里改成 left就好了 ,其他部分不用动。
}								// 至于为什么是 left, while结束的情况已经给出,可以思考思考。

leetcode34 在排序数组中查找元素的第一个和最后一个位置

---

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。

---

示例 1：
输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：
输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：
输入：nums = [], target = 0
输出：[-1,-1]

---

首先，如果 target在数组中是存在的，我们一定是可以找到它的。
比如对于一个 array [1，3，5，7]，target=7
我们最终会使left和right都指向7，此时mid也指向7.
也就是说二分可以做到排除除了target之外的所有元素。

---

由于我们要找target的左边界索引，所以即使我们遇到了mid=target，也要right=mid-1；因为我们还想看看在左侧是不是还能有一个更小的索引值。

随着不断的right=mid-1；此时开区间(left,right)里不会有target了，因为如果还有的话，就一定会被发现，然后执行right=mid-1；

此时有以下这几种情况。

• left和right都指向target
  
  
• left和right有一个指向了target
  
  
• left和right都没有指向target。但此时我们要注意，本来是有的，之所以闭区间[left,right]里没有了，是由于right的不断左移 (因为找到 target时 right也会左移) 造成的，left的右移是不会去造成开区间[left,right]里没有target的。
• 所以当[left,right]里第一次没有target时，此时right的右边（right+1）就是target。
  

将这几种情况分析完之后，不难发现，循环跳出后，最后target的左边界索引都是left
所以

int binarySearch(int[] nums,int target,int left, int right){
    while (left <= right) {										// 这里 注意是 <=
        int mid = left + ((right - left) >> 1);				
        if (nums[mid] >= target) {
            right = mid - 1;
        }else {        
            left = mid + 1;
        }
    }
    // 循环跳出后,返回left 
    return left;
}

对于右边界，同样的思路，left不断右移(left=mid+1)，最后的情况也是开区间(left,right)内不再有target，那时的情况也和上述一模一样。
此时再来看循环跳出时，right所在的位置即为右边界。

int binarySearch(int[] nums,int target,int left, int right){
    while (left <= right) {										// 这里 注意是 <=
        int mid = left + ((right - left) >> 1);				
        if (nums[mid] <= target) {
            left = mid + 1;
        }else {        
            right = mid - 1;
        }
    }
    // 循环跳出后,返回right 
    return right;
}

查找某数出现的次数

int binary_search(int *arr, int target, int left, int right){
    if (left > right) return 0;		// 退出 出口
    int mid = (left + right) >> 1;
    if (arr[mid] == target){
        int cnt1, cnt2=cnt1=mid;
        if (cnt1 >left && (arr[cnt1] == arr[cnt1 - 1]))  cnt1--;	// 当找到目标元素时,尽可能向两边去找目标元素。
        if (cnt2 <right && (arr[cnt2] == arr[cnt2 + 1]))  cnt2++;
        return 1 + (cnt2 -cnt1) + binary_search(arr, target, left, cnt1 - 1) + binary_search(arr, target, cnt2 + 1, right);
    }
    else if (arr[mid] > target)
        binary_search(arr, target, left, mid - 1);
    else
        binary_search(arr, target, mid + 1, right);
}