【la】二分搜索

以下三种题型「搜索区间」全都统⼀成两端都闭，好记，注意修改 nums[mid] == target 条件处的代码和返回的逻辑。
统一模板：

int binary_search(int[] nums, int target) {
	int left = 0, right = nums.length - 1;
	
	while(left <= right) {
		int mid = left + (right - left) / 2;
		if (nums[mid] < target) {
			left = mid + 1;
		} else if (nums[mid] > target) {
			right = mid - 1;
		} else if(nums[mid] == target) {
			1. XXX
		}
	}
	 2. XXX;
}

题型一：基本二分查找，寻找某个数，返回其下标
1 处：找到结果，直接返回。 return mid;
2 处：没有结果，返回-1。 return -1;

题型二：寻找左侧边界
1处：由于寻找左侧边界，如果 nums[mid] == target，要将区间缩小为 [ left , mid - 1] 。 right = mid - 1;
2处：由于寻找左侧边界，所以应该将 left 返回，要对 left 做一些判断。

 if (left >= nums.length || nums[left] != target) {
		return -1;
	}
	return left;

题型三：寻找右侧边界
1处：由于寻找右侧边界，如果 nums[mid] == target，要将区间缩小为 [ mid + 1 , right ]，向右缩。left = mid + 1;
2 处：由于寻找左侧边界，所以应该将 right 返回，要对 right 做一些判断。

if (right < 0 || nums[right] != target) {
		return -1;
	}
	return right;

题型一：基本二分查找，寻找某个数，返回其下标

因为我们初始化 right = nums.length - 1
所以决定了我们的「搜索区间」是 [left, right]
所以决定了 while (left <= right)
同时也决定了 left = mid+1 和 right = mid-1
因为我们只需找到⼀个 target 的索引即可
所以当 nums[mid] == target 时可以⽴即返回

int binary_search(int[] nums, int target) {
	int left = 0, right = nums.length - 1;
	
	while(left <= right) {
		int mid = left + (right - left) / 2;
		if (nums[mid] < target) {
			left = mid + 1;
		} else if (nums[mid] > target) {
			right = mid - 1;
		} else if(nums[mid] == target) {
		// 直接返回
		return mid;
		}
	}
	// 直接返回
	return -1;
}

题型二：寻找左侧边界的二分查找

int left_bound(int[] nums, int target) {
	int left = 0, right = nums.length - 1;
	while (left <= right) {
		int mid = left + (right - left) / 2;
		if (nums[mid] < target) {
			left = mid + 1;
		} else if (nums[mid] > target) {
		right = mid - 1;
		} else if (nums[mid] == target) {
			// 别返回，锁定左侧边界
			right = mid - 1;
		}
	}
	// 最后要检查 left 越界的情况
	if (left >= nums.length || nums[left] != target) {
		return -1;
	}
	return left;
}

题型三：寻找右侧边界的二分查找

int right_bound(int[] nums, int target) {
	int left = 0, right = nums.length - 1;
	while (left <= right) {
		int mid = left + (right - left) / 2;
		if (nums[mid] < target) {
			left = mid + 1;
		} else if (nums[mid] > target) {
			right = mid - 1;
		} else if (nums[mid] == target) {
		// 别返回，锁定右侧边界
			left = mid + 1;
		}
	}
	// 最后要检查 right 越界的情况
	if (right < 0 || nums[right] != target) {
		return -1;
	}
	return right;
}

704. 二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，
写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-search
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public int search(int[] nums, int target) {
        int left = 0,right = nums.length-1;
        // 查找区间 [ left,right ]
        while (left <= right){
            int mid = left + (right - left) / 2;

            if (nums[mid] > target){
                // 将区间缩小为 [left,mid - 1]
                right = mid - 1;
            }else if (nums[mid] < target){
                // 将区间缩小为 [ mid + 1,right]
                left = mid + 1;
            }else if (nums[mid] == target){
                // 找到结果，可以直接返回了
                return mid;
            }
        }
        return -1;
    }
}

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

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

进阶：
    你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗？
 
示例 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]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public int[] searchRange(int[] nums, int target) {
        // 求左右边界
        int[] res = new  int[2];
        res[0] = searchLeft(nums, target);
        res[1] = searchRight(nums, target);
        return res;
    }

    public int searchLeft(int[] nums, int target) {
        // 求左边界
        int left = 0,right = nums.length - 1;
        while (left <= right){
            int mid = left + (right - left)/2;
            if (nums[mid] < target){
                // [mid + 1 , right]
                left = mid + 1;
            }else if (nums[mid] > target){
                // [left , mid - 1]
                right = mid - 1;
            }else if (nums[mid] == target){
                // [ left , mid - 1]
                right = mid - 1;
            }
        }

        if (left >= nums.length || nums[left] != target){
            return -1;
        }
        return left;
    }

    public int searchRight(int[] nums, int target) {
        // 求右边界
        int left = 0,right = nums.length - 1;
        while (left <= right){
            int mid = left + (right - left)/2;
            if (nums[mid] < target){
                // [mid + 1 , right]
                left = mid + 1;
            }else if (nums[mid] > target){
                // [left , mid - 1]
                right = mid - 1;
            }else if (nums[mid] == target){
                // [ mid + 1,right]
                left = mid + 1;
            }
        }

        if (right < 0 || nums[right] != target){
            return -1;
        }
        return right;
    }
}