不是只有顺序表才能用二分查找leetcode34/33/162/153——二分查找篇

苏钟白

于 2022-12-07 16:52:58 发布

阅读量212

点赞数

分类专栏： leetcode和ccf刷题笔记文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/xuranyi/article/details/128193232

版权

leetcode和ccf刷题笔记专栏收录该内容

42 篇文章 2 订阅

订阅专栏

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]

提示：
0 <= nums.length <= 105
-109 <= nums[i] <= 109
nums 是一个非递减数组
-109 <= target <= 109

思路和代码：

自己的思路：这是几题二分查找个人感觉最好写的，虽然自己的思路有点笨。

首先二分查找的一般思想就是在一个区间范围内判断中间值与要查找的值的大小，如果相等说明找到。如果中间值小于target，那么就在中间值的右边区间查找，否则再中间值的左边区间查找。时间复杂度是O（logn）。

听起来思路很简单，代码实现起来也很简单，但在不同的题目中应用其实有很多细节，尤其是越界或者死循环。

leetcode竞赛大佬灵茶山艾府实现二分查找用了三种写法，第一种是左闭右闭区间，第二种是左开右闭区间，第三种是左开右开区间。区别在于初始值，while的判断句，left和right如何更新以及最后的返回值。

感觉没必要啊这，写熟常见的一种就好了啊。

如在[left,right]区间找目标值，左闭右闭区间。 while循环是left<=right,left和right的初始值是0，len（nums）-1。在更新左右区间的时候left=mid+1，right=mid-1。

nums = [1, 2, 4, 5, 6, 7, 8, 9]
target = 6


def binaryFind1(nums, target):
    left, right = 0, len(nums)-1
    while left <= right:
        mid = left + (right - left)//2
        # 找到就返回位置
        if nums[mid] == target:
            return mid
        # 中间值比目标值大 在中间值左边区间找 [left, mid-1]
        if nums[mid] > target:
            right = mid - 1
        # 中间值比目标值小 在中间值右边区间找 [mid+1，right]
        else:
            left = mid + 1
    # 没有找到 返回-1
    return -1


ans = binaryFind1(nums, target)
print(ans)

回到这题中，先说一下自己的思路：

用两次二分，第一次查找最左边出现的值，第二次查找最右边出现的值。以找最左边出现的值为例，当当前值等于target时，当前值可能是第一个出现的也可能不是，所以还要继续往前找，right=mid-1.

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        n = len(nums)
        if n == 0:
            return [-1,-1]
        start, end = -1, -1

        #查找第一个位置
        left, right = 0, n-1
        while left <= right:
            mid = left + (right - left)//2
            if nums[mid] > target:
                right = mid - 1
            elif nums[mid] < target:
                left = mid + 1
            else:
                start = mid
                right = mid -1
        
        # 查找最后一个位置
        left, right = 0, n-1
        while left <= right:
            mid = left + (right - left)//2
            if nums[mid] > target:
                right = mid - 1
            elif nums[mid] < target:
                left = mid + 1
            else:
                end = mid
                left = mid + 1
        
        return [start,end] if start!=-1 else [-1,-1]

再说一下官方视频的思路。总体方向一样，就是在代码的细节上不太一样。官方也是用了两次二分查找，一次查找第一个位置，一次查找最后一个位置。之所以还要写下来，觉得代码有点意思。

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        n = len(nums)
        if n == 0:
            return [-1,-1]
        start, end = -1, -1

        #查找第一个位置
        left, right = 0, n-1
        while left <  right:
            mid = left + (right - left)//2
            if nums[mid] < target:
                left = mid + 1
            elif nums[mid] == target:
                right = mid
            else:
                right = mid - 1
        if nums[left] == target:
            start =  left
        else:
            start =  -1
            
        
        # 查找最后一个位置
        left, right = 0, n-1
        while left < right:
            mid = left + (right - left + 1)//2
            if nums[mid] < target:
                left = mid + 1
            elif nums[mid] == target:
                left = mid
            else:
                right = mid - 1
        end = left
        
        return [start,end] if start!=-1 else [-1,-1]

找不同：

一是while判断句是left < right,跳出循环时一定有left==right；

二在找最后一个位置的时候，因为有left=mid，为了避免区间只有两个数的时候陷入死循环，所以在一开始的时候mid = left + (right - left + 1)//2。而这点在之前的一道困难题中也出现过。（https://blog.csdn.net/xuranyi/article/details/128121822 寻找两个正序数组中的中位数）。

三是这种写法，最后的left（right）就是要找的结果。

个人总结就是二分查找涉及到left或者right=mid的时候，为了避免死循环，while判断句中的<=要用<。其次，left = mid的时候，mid要写成 left + (right - left + 1)//2。

33. 搜索旋转排序数组

题目：

整数数组 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

提示：
1 <= nums.length <= 5000
-104 <= nums[i] <= 104
nums 中的每个值都独一无二
题目数据保证 nums 在预先未知的某个下标上进行了旋转
-104 <= target <= 104

思路和代码

我这个想的乱七八糟，调试了很久稀里糊涂的通过。现在思路搞清楚了，总结如下。

还是一样先找中间值嘛，然后等于目标值就返回。

中间值大于目标值的话，如果正个数组是有序的话，那应该在中间值左边找，有right = left -1。但是此时的数组有中间值为界，是一半有序一半无序，所以什么情况下要在中间值右边找？就是当右边是无序的且目标值不可能在左边。（if nums[mid] > nums[right] and nums[left] > target])

同理，中间值小于目标值的话，正常应该在中间值右边找，有left = mid+1。而中间值的左边是无序（nums[mid] < nums[left] and nums[right] < target）的且目标值不可能在右边，就应该在左边找。

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        left, right = 0, len(nums)-1 
        while left <= right:
            mid = left + (right-left)//2
            if nums[mid] == target:
                return mid
            elif nums[mid] < target:
                #左边是乱序的且结果不可能在右边
                if nums[left] > nums[mid] and nums[right] < target:
                    right = mid - 1
                else:
                    #有序的话 中间值小于目标值 本来应该在右区间 [mid+1,right]找
                    left = mid + 1
            else:
                #右边是乱序的且结果不可能在左边
                if nums[mid] > nums[right] and nums[left] > target:
                    left = mid + 1
                else:
                     #有序的话 中间值大于目标值 本来应该在左区间 [left,mid - 1]找
                    right = mid -1
        return -1

162. 寻找峰值

题目

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

给你一个整数数组 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[i] != nums[i + 1]（明晃晃的提示），在选择中间值的左边还是右边的时候，要判断中间值和中间值的下一个值的大小关系。如果中间值大于下一个值，在中间值的左边肯定会有峰值。但此时中间值本身也可能值峰值，所以right = mid，否则left= mid+1。

class Solution:
    def findPeakElement(self, nums: List[int]) -> int:  
        left, right = 0, len(nums)-1
        while left < right:
            # +的优先级高于>>
            mid = left + ((right-left)>>1)  
            if nums[mid] > nums[mid+1]:
                right = mid
            else:
                left = mid + 1
        return right

153. 寻找旋转排序数组中的最小值

题目
已知一个长度为 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) 的算法解决此问题。

示例 1：

输入：nums = [3,4,5,1,2]
输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。
示例 2：

输入：nums = [4,5,6,7,0,1,2]
输出：0
解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。
示例 3：

输入：nums = [11,13,15,17]
输出：11
解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。

提示：
n == nums.length
1 <= n <= 5000
-5000 <= nums[i] <= 5000
nums 中的所有整数互不相同
nums 原来是一个升序排序的数组，并进行了 1 至 n 次旋转

思路和代码：

这题我前两天写半天没写出来，今天几分钟通过了，哎呀，在状态的时候写代码太爽了。

我的思路就是比较中间值和左边的值，如果中间值小于左边的值，说明最小值在左边，中间值也可能是最小值，所以right=mid，否则在右边。

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

看了官方的代码，写的太好看了。思路差不多啦，就是换成了中间值和右边值比较，然后最后返回的是nums[left]。这里为啥返回nums[left]，如[7,0],此时nums[mid] > nums[right],left=1,而此时要返回的是nums[1]。

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