算法-03-二分查找

时间 2020-11-19

标签 java 数组优化编码指针 code 排序 element leetcode get 栏目应用数学繁體版

原文原文链接

3 二分查找

3.1 介绍

二分查找也叫折半查找，顾名思义，就是查找的时候只查找其中的一半，这样的话大大下降了查找的时间复杂度，为 O(log n) ，其中n为数组的长度
二分查找也能够看做双指针的一种特殊状况，但咱们通常会将两者区分。
- 双指针类型的题，指针一般是一步一步移动的；
- 二分查找时，指针每次移动半个区间长度。
注意：
- 对于端点上的处理（若是对端点的处理不够细心，有可能会致使没法得出正确答案或者没法退出循环等问题）
  - 端点的处理方式：左闭右开（符合大多数语言的习惯），左闭右闭（方便处理边界条件）
  - 首先，养成固定使用一个方式处理的习惯
  - 其次，思考当区间中有一个或两个或没有元素时，是否能正确执行并退出循环
- 二分查找中关于mid的选取
  - mid良好的赋值方式应为 mid = low + ((high - low) / 2) ，而不是 mid = (low + high) / 2，这是由于当数组较大时，可能会出现溢出的状况
  - 对mid向上仍是向下取整要根据实际状况来判断
- while(left <= right) 和 while(left < right) 的区别
  - while(left <= right) 表示在区间中还剩下一个元素的时候，咱们还要在进行一次循环
    - 一般和 right = mid -1 ， left = mid + 1 配合使用
  - while(left < right) 表示在区间中还剩下一个元素的时候，中止循环
    - 一般和 right = mid ，left = mid + 1 或 right = mid - 1 ，left = mid 配合使用
来自 LeetCode @liweiwei1419 对于二分搜索编码的建议
- 循环终止条件写成：while (left < right) ，表示退出循环的时候只剩下一个元素；
- 在循环体内考虑如何缩减待搜索区间，也能够认为是在待搜索区间里排除必定不存在目标元素的区间；
- 根据中间数被分到左边和右边区间，来调整取中间数的行为；
- 如何缩小待搜索区间
  - 从 nums[mid] 知足什么条件的时候必定不是目标元素去考虑，进而考虑 mid 的左边元素和右边元素哪一边可能存在目标元素。
  - 一个结论是：当看到 left = mid 的时候，取中间数须要上取整，这一点是为了不死循环；
- 退出循环的时候，根据题意看是否须要单独判断最后剩下的那个数是否是目标元素。
- 边界设置的两种写法：
  - right = mid 和 left = mid + 1 和 mid = left + (right - left) / 2 必定是配对出现的
  - right = mid - 1 和 left = mid 和 mid = left + (right - left + 1) / 2 必定是配对出现的
使用二分查找的要点
- 找到某些规则或规律使得指针能够一次移动一半的区间

69. x 的平方根（Easy）

思路java
- 同2.6练习中的367

代码数组

public int mySqrt(int x) {
    if (x <= 1) {
        return x;
    }
    if (x < 4) {
        return  1;
    }
    int left = 2;
    int right = x / 2;
    int mid = 0;
    while (left <= right) {
        mid = left + (right - left) / 2;
        long temp = (long)mid * (long)mid;
        if (temp < x) {
            left = mid + 1;
        } else if (temp > x) {
            right = mid - 1;
        } else {
            return mid;
        }
    }
    return (long)mid * (long)mid > x ? mid - 1 : mid;
}

注意：优化
- int 除 int 会致使直接向下取整，这里致使了精度上的损失。因此，最后要多判断一下 mid - 1 的平方
- int 乘 int 会先得出int类型的结果，而后将这个结果转换成long，这回致使溢出，因此在乘以前要先转成long类型或者统一使用 long 最后在返回的时候转成 int

3.3 查找区间

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

分析编码
- 使用二分查找找一个特定的数字并不难实现天然而然的，能够想到，咱们先找到这个target，而后从target的位置开始试探，经过试探能够找出第一次出现的位置和最后一个出现的位置。
  - 理想状况下，只须要几回试探便可找到，这样时间复杂度为 O(log n)
  - 可是最坏的状况，当一个数组中所有都是target时，那么这样时间复杂度就会升级成为 O(n) ，不符合题目要求
- 那么能不能经过调整二分查找的一些策略，找到咱们须要的位置呢？
  - 以找第一次出现的位置举例
  - 找到target以后，不着急中止循环，而是将right定位在这个位置。而后继续向前查找，直到找不到位置。那么最后一次right的位置就是它的起始位置了

代码指针

public int[] searchRange(int[] nums, int target) {
    if (nums == null || nums.length == 0) {
        return new int[]{-1, -1};
    }
    if (nums.length <= 1) {
        return nums[0] == target ? new int[]{0, 0} : new int[] {-1, -1};
    }

    int[] res = new int[]{-1, -1};
    int left = 0;
    int right = nums.length - 1;

    // 找到第一次出现的位置
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] >= target) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    res[0] = nums[right] != target ? -1 : right;
    if (res[0] == -1) {
        return new int[] {-1, -1};
    }

    // 找最后一次出现的位置
    left = right;
    right = nums.length - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] > target) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    res[1] = nums[left] == target ? left : left - 1;

    return res;
}

注意：code
- 两次二分查找时对于左右边界上的处理，若是处理不当，会致使死循环的错误

3.4 旋转数组查找数字

81. 搜索旋转排序数组 II（Medium）

分析排序
- 仔细观察旋转后的数组会发现，旋转过的数组分为两部分，这两部分都是有序的，既然是有序的，那么就可使用二分查找进行搜索
- 记数组下标为 0,1,...,i,i+1,...,n-1，其中 nums[i+1] < nums[i]
- 那么咱们只须要对 [0,i] 和 [i+1, n-1] 这两块分别进行二分搜索便可，那么只须要找到 i 便可
  - 要找到 i 必然要对数组进行遍历，而且由于数组中存在重复的元素，因此必需要遍历整个数组，才能肯定出 i 。所以，这一部分的时间复杂度为 O(n)
- 找到 i 时间复杂度为 O(n) ，二分查找时间复杂度为 O(log n)，总的时间复杂度为 O(n)

代码element

public boolean search(int[] nums, int target) {
    if (nums.length == 0) {
        return false;
    }
    if (nums.length == 1) {
        return nums[0] == target;
    }
    int flag = 0;
    for (int i = 0; i < nums.length - 1; i++) {
        if (nums[i] > nums[i + 1]) {
            flag = i;
        }
    }
    
    return binarySearch(0, flag, nums, target) || binarySearch(flag + 1, nums.length - 1, nums, target);
}

public boolean binarySearch(int left, int right, int[] nums,int target) {
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] > target) {
            right = mid - 1;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else {
            return true;
        }
    }
    return false;
}

改进（来自LeetCode官方题解）leetcode
- 要使用二分搜索，那么就要求被搜索的区间是有序的，而由题目给出的数组是局部有序的，那么咱们能不能只在有序的部分进行搜索呢，忽略无序部分？
- 这启示咱们能够在常规二分搜索的时候查看当前 mid 为分割位置分割出来的两个部分 [left, mid] 和 [mid + 1, right] 哪一个部分是有序的，并根据有序的那个部分肯定咱们该如何改变二分搜索的上下界，由于咱们可以根据有序的那部分判断出 target 在不在这个部分：
  - 若是 [left, mid]是有序数组，且 target 的大小知足 [nums[left],nums[mid])，则咱们应该将搜索范围缩小至 [left, mid-1]，不然在 [mid + 1, right] 中寻找。
  - 若是 [mid, right] 是有序数组，且 target 的大小知足 (nums[mid+1],nums[right]]，则咱们应该将搜索范围缩小至 [mid + 1, right]，不然在 [left, mid - 1] 中寻找。
- 时间复杂度 O(log n)

实现get

public boolean search(int[] nums, int target) {
    if (nums.length == 0) {
        return false;
    }
    if (nums.length == 1) {
        return nums[0] == target;
    }
    int left = 0;
    int right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            return true;
        }
        if (nums[left] == nums[mid]) {
            left++;
        } else if (nums[mid] <= nums[right]) {
            // 右边是有序的
            if (target > nums[mid] && target <= nums[right]) {
                // target落在有序区间内
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        } else {
            // 左边是有序的
            if (target >= nums[left] && target < nums[mid]) {
                // target落在有序区间内
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
    }

    return false;
}

要点：如何判断哪边有序？
- 由于数组存在重复数字，因此，当 nums[mid] == nums[left] 时，咱们没法肯定哪边是递增的，这时须要将 left 左移一个位置

3.5 基础练习

154. 寻找旋转排序数组中的最小值 II（Hard）

分析
- 旋转数组在旋转前，咱们能够表示为 [小数区间][大数区间] ，那么旋转以后，就是[大数区间][小数区间] 。咱们要找的这个最小值，就是大数区间变成小数区间的转折点
  - 哪怕数组中有重复元素也不例外，这个转折点必然是数组的最小值（想想，为何？）
- 记这个元素下标为 i
  - [0, i-1] 中的全部元素所有大于等于该元素
  - i 小于等于 [i+1, ... ,n-1] 中的全部元素
- 参考3.4，制定策略
  - 若是 nums[mid] < nums[right] ，那么转折点在 [left, mid-1]范围内
  - 若是 nums[mid] == nums[right] ，没法肯定转折点所在的区间，right左移一位
  - 若是 nums[mid] > nums[right] ，那么转折点在 [mid + 1, right]范围内
- 为何要使用 right 进行判断而不是使用 left ？
  - 若是整个数组都是有序的，使用 left 没法正确得出结果。（通过屡次尝试后发现，百思不得其解，参考了一下官方解法才发现关键在这里）

代码

public int findMin(int[] nums) {
    if (nums.length <= 2) {
        return nums.length == 1 ? 0 : Math.min(nums[0], nums[1]);
    }
    int left = 0;
    int right = nums.length - 1;
    int mid = 0;
    while (left < right) {
        mid = left + (right - left) / 2;
        if (nums[mid] < nums[right]) {
            right = mid;
        } else if (nums[right] == nums[mid]) {
            right--;
        } else {
            left = mid + 1;
        }
    }
    return nums[left];
}

注意
- 根据分析，当二分查找结束后，剩下的那个元素就是咱们要找的中间点，因而咱们采用 left < right 做为循环结束的条件

540. 有序数组中的单一元素（Medium）

分析
- 考虑单一元素出现先后，数组奇数和偶数下标对应的元素发生的变化
  - 在单一元素出现以前，第 i 对元素的下标是 2i-2 和 2i-1
  - 在单一元素出现以后，第 i 对元素的下标是 2i-1 和 2i
- 也就是说，
  - 在单一元素出现以前，对于奇数下标的元素，和它同样的元素在它的前面
  - 在单一元素出现以后，对于奇数下标的元素，和它同样的元素在它的后面
- 根据这样的规律，便可推断出单一元素是在 mid 的左边仍是右边
  - 若是 nums{mid] 和先后元素都不相同，则 nums{mid] 就是单一元素
  - 若是 mid 是奇数，且 nums{mid] 和后面元素相同，单一元素在 [left, mid-1] 范围内，否则就在 [mid+1, right] 范围内
  - 若是 mid 是偶数，且 nums{mid] 和后面元素相同，单一元素在 [mid+1, right]范围内，否则就在 [left, mid-1] 范围内

代码

public int singleNonDuplicate(int[] nums) {
    if (nums.length == 0) {
        return 0;
    }
    if (nums.length == 1 || nums[0] != nums[1]) {
        return nums[0];
    }
    if (nums[nums.length - 1] != nums[nums.length -2]) {
        return nums[nums.length - 1];
    }
    int left = 0;
    int right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] != nums[mid-1] && nums[mid] != nums[mid+1]) {
            return nums[mid];
        }
        if (mid % 2 != 0) {
            // mid是奇数
            if (nums[mid] == nums[mid + 1]) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        } else {
            // mid是偶数
            if (nums[mid] == nums[mid + 1]) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
    }
    return 0;
}

注意
- 由于涉及到了取 mid-1 和 mid+1 的操做，因此要对首尾的元素进行特殊操做，避免数组越界

3.6 进阶练习

4. 寻找两个正序数组的中位数（Hard）

分析
- 若是对时间复杂度没有要求
  - 那么将两个数组合并以后再查找中位数便可，这样的话时间复杂度为 O(m+n) 。
  - 那么可不能够不合并数组来进行查找呢？
    - 双指针，谁小移谁，一共移动 (m+n)/2 次后便可获得中位数，不过这样并无优化时间复杂度，只是把空间复杂度从 O(m+n) 下降到了 O(1)
- 若是对时间复杂度的要求有 log，一般都须要用到二分查找，这里我是没想出来有什么好方法，后来看了官方题解后恍然大悟
  - 根据中位数的定义，当 m+n 是奇数时，中位数是两个有序数组中的第 (m+n)/2 个元素，当 m+n 是偶数时，中位数是两个有序数组中的第 (m+n)/2 个元素和第 (m+n)/2+1 个元素的平均值。所以，这道题能够转化成寻找两个有序数组中的第 k 小的数，其中 k 为 (m+n)/2 或 (m+n)/2+1
  - 假设两个有序数组分别是 A 和 B。要找到第 k 个元素，咱们能够比较 A[k/2−1] 和 B[k/2−1]。因为 A[k/2−1] 和 B[k/2−1] 的前面分别有 A[0..k/2−2] 和 B[0..k/2−2]，即 k/2-1 个元素，对于 A[k/2−1] 和 B[k/2−1] 中的较小值，最多只会有 (k/2−1)+(k/2−1)≤k−2 个元素比它小，那么它就不能是第 k 小的数了。
  - 所以咱们能够概括出三种状况：
    - 若是 A[k/2−1]<B[k/2−1] ，则比 A[k/2−1] 小的数最多只有 A 的前 k/2-1 个数和 B 的前 k/2−1 个数，即比 A[k/2−1] 小的数最多只有 k-2 个，所以 A[k/2−1] 不多是第 k 个数，A[0] 到 A[k/2−1] 也都不多是第 k 个数，能够所有排除。
    - 若是 A[k/2−1]>B[k/2−1] ，则能够排除 B[0] 到 B[k/2−1]。
    - 若是 A[k/2−1]=B[k/2−1] ，则能够纳入第一种状况处理。
  - 对于某些状况，须要特殊处理
    - 若是 A[k/2−1] 或者 B[k/2−1] 越界，那么咱们能够选取对应数组中的最后一个元素。在这种状况下，咱们必须根据排除数的个数减小 k 的值，而不能直接将 k 减去 k/2。
    - 若是一个数组为空，说明该数组中的全部元素都被排除，咱们能够直接返回另外一个数组中第 k 小的元素。
    - 若是 k=1，咱们只要返回两个数组首元素的最小值便可。
- 总结
  - 核心思想：找到第k个小的数
  - 在两个数组中依次比较第 k / 2 个数字，谁小，就说明该数组的前 k / 2 个数字都不是第 k 个小的数，而后缩减该数组，直到 k = 1，而后取两个中最小的那一个
  - 每次缩减数组以后，k要减去数组减小的元素个数

代码

public double findMedianSortedArrays(int[] nums1, int[] nums2) {
    int len = nums1.length + nums2.length;
    int k = len / 2;
    if (len % 2 == 0) {
        int r1 = findKth(nums1, nums2, k);
        int r2 = findKth(nums1, nums2, k + 1);
        return (r1 + r2) / 2.0;
    } else {
        return findKth(nums1, nums2, k+1);
    }
}

private int findKth(int[] nums1, int[] nums2, int k) {
    int length1 = nums1.length;
    int length2 = nums2.length;

    // index表示的是排除元素以后，“新数组” 的开始位置
    int index1 = 0;
    int index2 = 0;

    while (true) {
        // 若是其中一个数组为空，则返回另一个数组的中位数
        if (index1 == length1) {
            return nums2[index2 + k - 1];
        }
        if (index2 == length2) {
            return nums1[index1 + k - 1];
        }
        // 当 k=1 时退出循环
        if (k == 1) {
            return Math.min(nums1[index1], nums2[index2]);
        }

        int half = k / 2;
        // 这步操做保证了newIndex不会超出数组长度
        int newIndex1 = Math.min(index1 + half, length1) - 1;
        int newIndex2 = Math.min(index2 + half, length2) - 1;
        int pivot1 = nums1[newIndex1], pivot2 = nums2[newIndex2];

        // k要减去每次排除的元素个数
        if (pivot1 <= pivot2) {
            k -= (newIndex1 - index1 + 1);
            index1 = newIndex1 + 1;
        } else {
            k -= (newIndex2 - index2 + 1);
            index2 = newIndex2 + 1;
        }
    }
}