Leetcode_二分法_leetcode的开放活动日题目二分法解决-CSDN博客

本文链接：https://blog.csdn.net/sc179/article/details/119709158

基本思路

1 思想：每次缩小一半搜索空间
2 模版如下：

left=0，right=nums.length-1
while(left<right)
循环内
3.1 mid=(left+right)/2，由于left<=mid<right，所以为了避免死循环，在下一轮中要么left＞mid(left=mid+1)，要么right<=mid(right=mid/mid-1)
3.2 mid=(left+right+1)/2，由于left<mid<=right，所以为了避免死循环，在下一轮中要么left>=mid(left=mid/mid+1)，要么right<mid(right=mid-1)
return left/right（最后一步left==right）

3 查找某个具体值，如果用left<=right，必须left=mid+1,right=mid-1,否则死循环；
4 其余情况，具体问题具体分析；

最长递增子序列

1 题目描述

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4

示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

提示：

1 <= nums.length <= 2500
-10⁴ <= nums[i] <= 10⁴

进阶：

你可以设计时间复杂度为 O(n²) 的解决方案吗？
你能将算法的时间复杂度降低到 O(n log(n)) 吗?

2 解题（Java）

解题思路：动态规划+二分查找

新建数组 cell，用于保存最长上升子序列；
对原序列进行遍历，将每位元素二分插入 cell 中：
- 如果 cell 中元素都比它小，将它插到最后；
- 否则，用它覆盖掉大于等于它的元素中最小的那个；
cell 未必是真实的最长上升子序列，但长度是对的；

代码

class Solution {
    public int lengthOfLIS(int[] nums) {
        List<Integer> cell = new ArrayList<>();
        cell.add(nums[0]);
        for (int i=1; i<nums.length; i++) {
            if (nums[i] > cell.get(cell.size()-1)) {
                cell.add(nums[i]);
            } else {
                int left = 0, right = cell.size() - 1;
                while (left < right) {
                    int mid = (left + right) / 2;
                    if (cell.get(mid) >= nums[i]) right = mid;
                    else left = mid+1;
                }
                cell.remove(left);
                cell.add(left, nums[i]);
            }
        }
        return cell.size();
    }
}

3 复杂性分析

时间复杂度：O(nlog(n)) ；
空间复杂度：O(n)；

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

1 题目描述

给定一个按照升序排列的整数数组 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]

2 解题（Java）

二分法：

class Solution {
    public int[] searchRange(int[] nums, int target) {
        if (nums.length==0) return new int[] {-1, -1};
        int start = -1, end = -1;
        int left = 0, right = nums.length - 1;
        while (left < right) {
            int mid = (left + right) / 2;
            if (nums[mid] >= target) right = mid;
            else left = mid + 1;
        }
        start = nums[left] == target ? left : -1;

        left = 0; right = nums.length - 1;
        while (left < right) {
            int mid = (left + right + 1) / 2;
            if (nums[mid] <= target) left = mid;
            else right = mid - 1;
        }
        end = nums[right] == target ? right : -1;

        return new int[] {start, end};
    }
}

3 复杂性分析

时间复杂度O(logN)：N为数组长度，共进行两次二分查找；
空间复杂度O(1)：定义了几个变量占用常数大小的额外空间；

*搜索旋转排序数组

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 。

示例 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

提示：

1 <= nums.length <= 5000
-10 ^ 4 <= nums[i] <= 10 ^ 4
nums 中的每个值都独一无二
nums 肯定会在某个点上旋转
-10 ^ 4 <= target <= 10 ^ 4

进阶：你可以设计一个时间复杂度为 O(log n) 的解决方案吗？

2 解题（Java）

解题思路

对于有序数组，可以使用二分查找的方法查找元素；
将数组从中间分开成左右两部分的时候，一定有一部分的数组是有序的，并根据有序的那个部分确定我们该如何改变二分查找的上下界；
如果 [left, mid - 1] 是有序数组，且 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] 中寻找;

在这里插入图片描述

代码

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

3 复杂性分析

时间复杂度O(logN)：其中 N 为 nums 数组的长度，时间复杂度即为二分查找的时间复杂度；
空间复杂度O(1)：几个变量占用常数大小的额外空间；

*旋转数组的最小数字

1 题目描述

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。

示例 1：

输入：[3,4,5,1,2]
输出：1

示例 2：

输入：[2,2,2,0,1]
输出：0

2 解题（Java）

2.1 解题思路

寻找旋转数组的最小元素即寻找右排序数组的首个元素 numbers[x] ，称 x 为旋转点；

在这里插入图片描述

排序数组的查找问题首先考虑使用二分法解决，其可将遍历法的线性级别时间复杂度降低至对数级别；

2.2 算法流程

1 初始化

声明 left, right 双指针分别指向 nums 数组左右两端；

2 循环二分

设 mid = (left + right) / 2 为每次二分的中点（ “/” 代表向下取整除法，因此恒有 left ≤ m < right ），可分为以下三种情况：

当 nums[mid] > nums[right]时： mid 一定在左排序数组中，即旋转点 x 一定在 [mid + 1, right] 闭区间内，因此执行 left = mid + 1；
当 nums[mid] < nums[right]时： mid 一定在右排序数组中，即旋转点 x 一定在[left, mid]闭区间内，因此执行 right = mid；
当 nums[mid] = nums[right]时：无法判断 mid 在哪个排序数组中，即无法判断旋转点 x 在 [left, mid]还是 [mid + 1, right]区间中。解决方案：执行 right = right - 1缩小判断范围；

3 返回值

当left = right时跳出二分循环，并返回旋转点的值 nums[left] 即可；

2.3 正确性证明

当 nums[mid] = nums[right]时，right = right - 1的正确性证明：

当 nums[mid] = nums[right] 时，无法判定 mid 在左（右）排序数组，自然也无法通过二分法安全地缩小区间，因为其会导致旋转点 x 不在区间 [left, right]内。举例如下：

设以下两个旋转点值为 0 的示例数组，则当 left = 0, right = 4 时 mid = 2，两示例结果不同。

示例一 [1, 0, 1, 1, 1]：旋转点 x = 1 ，因此 mid = 2 在右排序数组中；
示例二 [1, 1, 1, 0, 1]：旋转点 x = 3，因此 mid = 2 在左排序数组中；

而证明 right = right - 1正确（缩小区间安全性），需分为两种情况：

当 x < right时：易得执行 right = right - 1 后，旋转点 x 仍在区间 [left, right]内;
当 x = right时：执行 right = right - 1后越过（丢失）了旋转点 x ，但最终返回的元素值 nums[left] 仍等于旋转点值 nums[x] :
1. 由于 x = right，因此 nums[x]=nums[right]=nums[mid]，nums[x]≤number[left] ,所以nums[mid]≤number[left]；
2. 又由于 left≤mid<right 恒成立，因此有 mid < x，即此时 m 一定在左排序数组中，因此 nums[mid]≥nums[left] ;
3. 综合 1. , 2. ，可推出 nums[left] = nums[mid]，且区间 [left, mid] 内所有元素值相等，即有：nums[left]=nums[left+1]=⋯=nums[mid]=nums[x]。此时，执行 right = right - 1 后虽然丢失了旋转点 x ，但之后区间 [left, right]只包含左排序数组，二分下去返回的一定是本轮的 nums[left] ，而其与 nums[x]相等。

2.4 代码

class Solution {
    public int minArray(int[] numbers) {
        int left = 0;
        int right = numbers.length - 1;
        while (left < right) {
            int mid = (left + right) / 2;
            if (numbers[mid] > numbers[right]) left = mid + 1;
            else if (numbers[mid] < numbers[right]) right = mid;
            else right--;
        }
        return numbers[left];
    }
}

3 复杂性分析

时间复杂度O(log2N) ：即二分法时间复杂度，在特例情况下（例如 [1, 1, 1, 1]），会退化到 O(N)；
空间复杂度 O(1) ：变量left , right , mid占用常数大小的额外空间；

*0～n-1中缺失的数字

1 题目描述

一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

示例 1:

输入: [0,1,3]
输出: 2

示例 2:

输入: [0,1,2,3,4,5,6,7,9]
输出: 8

2 解题（Java）

2.1 解题思路

排序数组中的搜索问题，首先想到二分法解决；
根据题意，数组可以按照以下规则划分为两部分：
- 左子数组： nums[i] == i；
- 右子数组： nums[i] != i；
缺失的数字等于 “右子数组的首位元素” 对应的索引，因此考虑使用二分法进行查找；

在这里插入图片描述

2.2 算法流程

初始化：左边界 left = 0，右边界 right = len(nums) - 1，代表闭区间 [left, right] ；
循环二分：当 left ≤ right 时循环（即当闭区间 [left, right] 为空时跳出）：
- 计算中点 mid = (left + right) / 2，其中 “/” 为向下取整除法；
- 若 nums[mid] = mid，则 “右子数组的首位元素” 一定在闭区间 [mid + 1, right]中，因此执行 left = mid + 1；
- 若 nums[mid] != mid ，则 “左子数组的末位元素” 一定在闭区间 [left, mid - 1] 中，因此执行 right = mid - 1；
返回值：跳出时，left 和 right 分别指向 “右子数组的首位元素” 和 “左子数组的末位元素” 。因此返回 left 即可；

2.3 代码

class Solution {
    public int missingNumber(int[] nums) {
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] == mid) left = mid + 1;
            else right = mid - 1;
        }
        return left;
    }
}

3 复杂性分析

时间复杂度 O(log N)：二分法为对数级别时间复杂度；
空间复杂度 O(1)：几个变量占用常数大小的额外空间；

*寻找两个正序数组的中位数

1 题目描述

给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的中位数。

进阶：你能设计一个时间复杂度为 O(log (m+n)) 的算法解决此问题吗？

示例 1：

输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例 2：

输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

示例 3：

输入：nums1 = [0,0], nums2 = [0,0]
输出：0.00000

示例 4：

输入：nums1 = [], nums2 = [1]
输出：1.00000

示例 5：

输入：nums1 = [2], nums2 = []
输出：2.00000

提示：

nums1.length == m
nums2.length == n
0 <= m <= 1000
0 <= n <= 1000
1 <= m + n <= 2000
-10 ^ 6 <= nums1[i], nums2[i] <= 10 ^ 6

2 解题（Java）

2.1 解题思路

求中位数，其实就是求第 k 小数的一种特殊情况；
假设我们要找第 k 小数，我们可以每次循环排除掉 k/2 个数；

假设我们要找第 7 小的数字。

在这里插入图片描述

比较两个数组的第 k/2 个数字，如果 k 是奇数，向下取整；
也就是比较第 3 个数字，上边数组中的 4 和下边数组中的 3，哪个小，就表明该数组的前 k/2 个数字都不是第 k 小数字，将其排除，即 1，2，3 这三个数字不可能是第 7 小的数字，把它们排除掉；
再将 1349 和 45678910两个数组作为新的数组进行比较；
更一般的情况 A[1] ，A[2] ，A[3]，A[k/2] … ，B[1]，B[2]，B[3]，B[k/2] … ，如果 B[k/2]<A[k/2] ，那么B[1]，B[2]，B[3]，B[k/2]都不可能是第 k 小的数字；
橙色的部分表示已经去掉的数字：
由于我们已经排除掉了 3 个数字，就是这 3 个数字一定在最前边，所以在两个新数组中，我们只需要找第 7 - 3 = 4 小的数字就可以了，也就是 k = 4。此时两个数组，比较第 2 个数字，3 < 5，所以我们可以把小的那个数组中的 1 ，3 排除掉了；

在这里插入图片描述

我们又排除掉 2 个数字，所以现在找第 4 - 2 = 2 小的数字就可以了。此时比较两个数组中的第 k / 2 = 1 个数，4 == 4，由于两个数相等，所以无论去掉哪个数组中的都行，于是将下边的 4 去掉；
由于又去掉 1 个数字，此时我们要找第 1 小的数字，所以只需判断两个数组中第一个数字哪个小就可以了，也就是 4。所以第 7 小的数字是 4；

在这里插入图片描述

每次都是取 k/2 的数进行比较，有时候可能会遇到数组长度小于 k/2的时候：

在这里插入图片描述

此时 k / 2 等于 3，而上边的数组长度是 2，我们此时将箭头指向它的末尾就可以了。这样的话，由于 2 < 3，所以就会导致上边的数组 1，2 都被排除。造成下边的情况：

在这里插入图片描述

由于 2 个元素被排除，所以此时 k = 5，又由于上边的数组已经空了，我们只需要返回下边的数组的第 5 个数字就可以了；
从上边可以看到，无论是找第奇数个还是第偶数个数字，对算法并没有影响，而且在算法进行中，k 的值都有可能从奇数变为偶数，最终都会变为 1 或者由于一个数组空了，直接返回结果；
考虑采用递归的思路，为了防止数组长度小于 k/2，所以每次比较 min(k/2，len(数组) 对应的数字，把小的那个对应的数组的数字排除，将两个新数组进入递归，并且 k 要减去排除的数字的个数。递归出口就是当 k=1 或者其中一个数组长度是 0 ；

2.2 代码

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int len1 = nums1.length;
        int len2 = nums2.length;
        int leftK = (len1 + len2 + 1) / 2;
        int rightK = (len1 + len2 + 2) / 2;
        //如果n+m是偶数，k不为整数，转换为求第k-0.5小和第k+0.5小的数的平均数，得到第k小数；如果n+m是奇数，会求两次同样的第k小数，取平均值，依然是第k小数
        return (getKth(nums1, 0, len1 - 1, nums2, 0, len2 - 1, leftK) + getKth(nums1, 0, len1 - 1, nums2, 0, len2 - 1, rightK)) * 0.5;  
    }
    
    private int getKth(int[] nums1, int start1, int end1, int[] nums2, int start2, int end2, int k) {
        int len1 = end1 - start1 + 1;
        int len2 = end2 - start2 + 1;

        if (len1 == 0) return nums2[start2 + k - 1];
        if (len2 == 0) return nums1[start1 + k - 1];

        if (k == 1) return Math.min(nums1[start1], nums2[start2]);

        int start1New = start1 + Math.min(len1, k / 2);
        int start2New = start2 + Math.min(len2, k / 2);

        if (nums1[start1New-1] > nums2[start2New-1]) {
            return getKth(nums1, start1, end1, nums2, start2New, end2, k - Math.min(len2, k / 2));
        }
        else {
            return getKth(nums1, start1New, end1, nums2, start2, end2, k - Math.min(len1, k / 2));
        }
    }
}

3 复杂性分析

时间复杂度O(log(m+n))：每进行一次循环，我们就减少 k/2 个元素，所以时间复杂度是 O(logk)，而初始k=(m+n)/2，所以最终的时间复杂度也就是 O(log(m+n))；
空间复杂度O(1)：虽然我们用到了递归，但是可以看到这个递归属于尾递归，编译器不需要不停地堆栈，所以空间复杂度为 O(1)；

尾递归：

当编译器检测到一个函数调用是尾递归的时候，它就覆盖当前的活动记录而不是在栈中去创建一个新的；
因为递归调用是当前活跃期内最后一条待执行的语句，于是当这个调用返回时栈帧中并没有其他事情可做，因此也就没有保存栈帧的必要了；
通过覆盖当前的栈帧而不是在其之上重新添加一个，这样所使用的栈空间就大大缩减了，这使得实际的运行效率会变得更高；

*数值的整数次方

1 题目描述

实现函数double Power(double base, int exponent)，求base的exponent次方。不得使用库函数，同时不需要考虑大数问题。

示例 1:

输入: 2.00000, 10
输出: 1024.00000

示例 2:

输入: 2.10000, 3
输出: 9.26100

示例 3:

输入: 2.00000, -2
输出: 0.25000
解释: 2 ^ -2 = (1/2) ^ 2 = 1/4 = 0.25

说明:

-100.0 < x < 100.0
n 是 32 位有符号整数，其数值范围是 [−2 ^ 31, 2 ^ 31 − 1] 。

2 解题（Java）

2.1 解题思路

求 x ^ n 最简单的方法是通过循环将 n 个 x 乘起来，依次求 x ^ 1, x ^ 2, …, x ^ (n-1), x ^ n ，时间复杂度为 O(n)；
快速幂法可将时间复杂度降低至 O(log2 n)，以下从 “二进制” 和“二分法”两个角度解析快速幂法；

2.1.1 快速幂解析（二进制角度）

利用十进制数字 n 的二进制表示，可对快速幂进行数学化解释；
对于任何十进制正整数 n ，设其二进制为“bm…b3b2b1” （ bi为二进制某位值，i∈[1,m] ），则有：
1. 二进制转十进制： n = 1b1 + 2b2 + 4b3 + … + 2 ^ (m-1)bm；
2. 幂的二进制展开：x ^ n = x ^ (1b1 + 2b2 + 4b3 + … + 2 ^ (m-1)bm) = x ^ 1b1 * x ^ 2b2 * x ^ 4b3…x ^ (2 ^ (m-1))bm；
根据以上推导，可把计算 x^n转化为解决以下两个问题：
1. 计算 x ^ 1, x ^ 2, x ^ 4, …, x ^ (2^(m-1))的值：循环赋值操作x = x ^ 2即可；
2. 获取二进制各位b1, b2, b3, …,bm的值：循环执行以下操作即可：
  1. n & 1（与操作）：判断n二进制最右一位是否为1；
  2. n >> 1（移位操作）：n右移一位（即删除最后一位）；
3. 因此，应用以上操作，可在循环中依次计算x ^ (2 ^ 0 * b1)，x ^ (2 ^ 1 * b2), …x ^ (2 ^ (m-1) * bm)的值，并将所有x ^ (2 ^ (i - 1) * bi)累计相乘即可：
  1. 当bi = 0时：x ^ (2 ^ (i-1) * bi) = 1；
  2. 当bi = 1时：x ^ (2 ^ (i-1) * bi) = x ^ (2 ^ (i-1))；

在这里插入图片描述

2.1.2 快速幂解析（二分法角度）

快速幂实际上是二分思想的一种应用；
二分推导：x ^ n = x ^ n/2 * x ^ n/2 = (x ^ 2) ^ n/2，令n/2为整数，需要分为奇偶两种情况（设向下取整除法符号为“//”）:
1. 当n为偶数： x ^ n = (x ^ 2) ^ n//2；
2. 当n为奇数：x ^ n = x(x ^ 2) ^ n//2，即会多出一项x；
幂结果获取：
1. 根据二分推导，可通过x = x ^ 2操作，每次把幂从n降至n//2，直至将幂降为0；
2. 设res = 1，则初始状态x ^ n = x ^ n * res。在循环二分时，每当n为奇数时，将多出的一项x乘入res，当n=0时，返回res即可；

在这里插入图片描述

转化为位运算：
1. 向下整除n//2等价于右移一位n>>1；
2. 取余数n%2等价于判断二进制最右一位值n & 1；

2.2 算法流程

当x = 0时：直接返回0（避免后续x = 1/x操作报错）；
初始化res = 1;
当n<0时：把问题转化至n>=0的范围内，即执行x = 1/x, n = -n;
循环计算：当n=0时跳出：
1. 当n&1=1时：将当前x乘入res（即res *= x）；
2. 执行x = x ^ 2（即x *= x）；
3. 执行n右移一位（即n>>=1）；
返回res;

注：

Java 代码中 int32 变量 n∈[−2147483648,2147483647] ，因此当 n = -2147483648时执行 n = -n 会因越界而赋值出错。解决方法是先将 n 存入 long 变量 b ，后面用 b 操作即可。

2.3 代码

class Solution {
    public double myPow(double x, int n) {
        if(x == 0) return 0;
        long b = n;
        double res = 1.0;
        if(b < 0) {
            x = 1 / x;
            b = -b;
        }
        while(b > 0) {
            if((b & 1) == 1) res *= x;
            x *= x;
            b >>= 1;
        }
        return res;
    }
}