[算法学习05] 非有序数列的情况下使用二分查找

强风吹拂y

已于 2024-03-21 21:56:44 修改

阅读量856

点赞数 22

分类专栏：算法学习文章标签：算法学习

于 2024-03-08 14:45:01 首次发布

本文链接：https://blog.csdn.net/weixin_45066884/article/details/136421239

版权

算法学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

前言

算是对二分的一个小进阶，在数组不是有序排列的情况使用二分法得到答案。

1. LeetCode 162. 寻找峰值 https://leetcode.cn/problems/find-peak-element/solutions/1987497/by-endlesscheng-9ass/

峰值元素是指其值严格大于左右相邻值的元素。

给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。

你可以假设 nums[-1] = nums[n] = -∞ 。

你必须实现时间复杂度为 O(log n) 的算法来解决此问题。

示例 1：

输入：nums = [1,2,3,1]

输出：2
解释：3 是峰值元素，你的函数应该返回其索引 2。

示例 2：

输入：nums = [1,2,1,3,5,6,4]
输出：1 或 5 
解释：你的函数可以返回索引 1，其峰值元素为 2；
     或者返回索引 5， 其峰值元素为 6。

提示：

1 <= nums.length <= 1000
-231 <= nums[i] <= 231 - 1
对于所有有效的 i 都有 nums[i] != nums[i + 1]

解题思路：

出现峰值的四种情况，如上图所示。

细节点：nums[-1] nums[n] = 负无穷即数组的两端最小，且nums[n-1] 要么是峰顶，要么是峰顶的右侧，不需要考虑在内

对于所有有效的 i 都有 nums[i] != nums[i + 1]，这句话也非常重要，说明nums[mid]和nums[mid+1] 一定可以分出大小。

考虑上面的四种情况，我们可以得出以下结论

如果 nums[mid] >= nums[mid+1],说明峰值出现的情况符合2和3，即mid的右边肯定不存在峰值。right = mid - 1

如果nums[mid] < nums[mid+1],说明峰值出现的情况符合1和4，即mid的左侧肯定不存在峰值。

left = mid + 1

以下是代码

class Solution:
    def findPeakElement(self, nums: List[int]) -> int:
        left, right = 0, len(nums)-2
        while left <= right:
            mid = (left + right) // 2
            if nums[mid] < nums[mid+1]:
                left = mid + 1
            else:
                right = mid - 1
        return left

2. leetcode 153. 寻找旋转排序数组中的最小值 https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array/solutions/1987499/by-endlesscheng-owgd/

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次旋转后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：

若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]

注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。

给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

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

解题思路：

原数组是一段递增数组，旋转后变成两端递增数组，最小值会出现在哪？答案是两端数组的分界点。

数组中的最后一个值，要么是最小值（分界点），要么是分界点的右侧，记作nums[-1]。

如果nums[mid]，≥nums[-1]，那么不可能是一段数组的情况，[left,mid]这个区间上的元素都在第一段数组中，也就是最小值的左侧。所以 left 更新为 mid + 1

反之，也就是 nums [mid] < nums[-1] 说明要么是一段数组，要么是mid在第二段数组上，说明[mid, right] 在最小值的右侧。所以right 更新为 mid - 1

以下是代码

class Solution:
    def findMin(self, nums: List[int]) -> int:
        left, right = 0, len(nums)-2
        while left <= right:
            mid = (left + right) // 2
            if nums[mid] < nums[right + 1]:
                right = mid - 1
            else:
                left = mid + 1
        return nums[left]

3. Leetcode 154. 寻找旋转排序数组中的最小值 II https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array-ii/

解题思路：

和上一题的区别在于，数组中可能出现重复的数字，这会导致什么情况呢

nums[mid] 和 nums[-1] 相等，这就没办法判断你是在第一段递增数组上，还是在第二段递增数组上。因此我们只需要加上一个判断条件 if nums[mid] == nums[right+1] 区间外的第一个元素，如果相等， right = right - 1。

原因是，如果right+1是最小值所在的位置，那么mid和他相等，最小值仍在区间中存在。

如果right+1不是最小值那么排除掉一个错误答案。

还有就是我们为什么要和right+1比较？

我们要比较的元素只要是最小值或者是最小值的右侧即可。

当 mid > right+1 说明 mid 在最小值的左侧，所以 left = mid+1更新区间去右边找最小值

当mid < right+1 right+1本身就是最小值的右侧，而mid比right+1还小，所以最小值应该在左侧，所以更新区间为 right = mid -1

在循环结束时，right 可能已经指向了一个比最小值还大的位置（尤其是当数组中存在重复元素时）。因此，返回 nums[right] 可能会导致得到错误的结果。而 nums[left] 始终指向的是最小值的位置（或右侧），因此它是正确的选择。

代码如下

class Solution:
    def findMin(self, nums: List[int]) -> int:
        left, right = 0, len(nums)-2
        while left <= right:
            mid = (left + right) // 2
            if nums[mid] > nums[right+1]:
                left = mid + 1
            elif nums[mid] < nums[right+1]:
                right = mid - 1
            else:
                right = right - 1
        return nums[left]

4. Leetcode 33. 搜索旋转排序数组 https://leetcode.cn/problems/search-in-rotated-sorted-array/solutions/1987503/by-endlesscheng-auuh/

解题思路：

先使用第2题的方法找到分界点，然后将target和nums[-1]比较，确定一下在target在哪段递增数组中，接着对相应的数组使用简单的二分查找，即可获得正确答案。

代码如下：

def findMin(nums):
    left, right = 0, len(nums)-2
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] >= nums[-1]:
            left = mid + 1
        else:
            right = mid - 1
    return left  

def lower_bound(nums, target, left, right):
    while left < right:
        mid = (left + right) // 2
        if nums[mid] < target:
            left = mid + 1
        else:
            right = mid
    return right 

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        edge = findMin(nums)
        if nums[-1] < target:
            end = lower_bound(nums, target, 0, edge)
        else:
            end = lower_bound(nums, target, edge, len(nums))
        return -1 if nums[end] != target else end