【Leetcode】二分查找

2、步骤：

（1）定义left = 0，right = nums.length-1 

（2）取中间的元素mid = （left+right）/2 与目标值进行比较；

如果中间的元素等于目标值，则查找成功，返回对应的位置；

如果中间的元素 大于 目标值，则说明目标值可能在 左半部分 ，right=mid-1；

如果中间的元素 小于 目标值，则说明目标值可能在 右半部分 ，left = mid+1；

如果范围缩小到只有一个元素，即right ==left == mid，但该元素不等于目标值，则查找失败，目标值不存在。

（3）重复（2）的步骤知道得到结果

3、例题：搜索旋转排序数组

会存在区别的两种处理情况：数组中的值有相同的、都不相同。

为什么会有区别：

1、如果数组中的值互不相同，那么nums[mid] 和nums[l]、nums[r]都不相同。所以一定会有谁大于谁，判断nums[0]或者nums[length-1]的值与nums[mid]的关系（nums[0]<=nums[mid]则在左边），即可得知nums[mid]在左右哪一段，知道了在哪一段以后（例如左边），如果target也在左段，只要nums{mid}>target，r=mid -1；否则，不管是target在右段，还是说target也在左段但nums{mid}<target，都要让 l = mid+1。右段同理，如果target也在右端，只要nums{mid}<target，l=mid +1；否则不管是target在左端还是target也在右但是nums{mid}>target，都要让r=mid -1。要注意的是，判断target或者nums[mid]在左边还是右边的时候，要是>=或者<=。

2、如果数组中的值有相同的，那么在判断target（nums【mid】） 和nums[l]、nums[r]的大小关系时，可能会存在三者相等的时候，这样的话不能判断在左边还是右边，不能直接r=mid -1或者 l = mid+1，只能r--;l++;然后在新的区间上继续二分查找：

        如果nums【mid】>=nums[left]，（mid肯定在在left右边，又nums【mid】>=nums[left]），所以nums【mid】肯定在左段，如果nums{left}<=target（target可能在左也可能在右边） && target < nums[mid]   ，令r=mid -1；否则，不管是target在右段，还是说target也在左段但nums{mid}<target，都要让 l = mid+1。

数组中的值互不相同时，左右一定是有序的，只需要跟nums【0】比就可以知道在左边还是右边。

但是有重复的不一样，要判断有序（某个连续区间内元素满足递增的顺序）只能使用左边界nums【left】与nums【mid】比较，而不是nums【0】。

（1）整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4

示例 2：

输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1

示例 3：

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

class Solution {
    public int search(int[] nums, int target) {
        int n = nums.length;
        if (n == 0) {
            return -1;
        }
        if (n == 1) {
            return nums[0] == target ? 0 : -1;
        }
        int l = 0, r = n - 1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (nums[mid] == target) {
                return mid;
            }
            if (nums[0] <= nums[mid]) {
                if (nums[0] <= target && target < nums[mid]) {
                    r = mid - 1;
                } else {
                    l = mid + 1;
                }
            } else {
                if (nums[mid] < target && target <= nums[n - 1]) {
                    l = mid + 1;
                } else {
                    r = mid - 1;
                }
            }
        }
        return -1;
    }
}

(2)已知存在一个按非降序排列的整数数组 nums ，数组中的值不必互不相同。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转 ，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。

给你 旋转后 的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在这个目标值 target ，则返回 true ，否则返回 false 。

你必须尽可能减少整个操作步骤。

示例 1：

输入：nums = [2,5,6,0,0,1,2], target = 0
输出：true

示例 2：

输入：nums = [2,5,6,0,0,1,2], target = 3
输出：false