继续创造,加速成长!这是我参与「日新方案 10 月更文应战」的第8天,点击检查活动概况

算法题解系列文章旨在精选重点与易错的算法题,总结常见的算法思路与可能呈现的过错,以实战习题的方式了解算法,运用算法。

本文已收录于算法刷题系列专栏: 算法题解 欢迎订阅,继续更新。

欢迎重视 点赞 收藏⭐ 留言

代码成果万世基,积沙镇海;梦想永在凌云意,神采飞扬;

704. 二分查找

标题

704. 二分查找 难度:easy

给定一个n个元素有序的(升序)整型数组nums和一个目标值target,写一个函数搜索nums中的target,假如目标值存在回来下标,不然回来-1

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解说: 9 呈现在 nums 中而且下标为 4

示例2:

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解说: 2 不存在 nums 中因而回来 -1

提示:

  1. 你能够假定nums中的一切元素是不重复的。
  2. n将在[1, 10000]之间。
  3. nums的每个元素都将在[-9999, 9999]之间。

办法一:二分查找

思路

看标题其实就知道是用「二分查找」了,而且「二分查找」也是比较贴近实践开发应用的;

相对于暴力遍历的 O(n),二分查找只需要 O(logn),为什么二分查找会这么快呢,那咱们接下来讲讲;

在升序数组 nums 中寻找目标值 target,对于特定下标 i,比较 nums[i]target 的巨细:

  • 假如 nums[i] = target,则下标 i 即为要寻找的下标;
  • 假如 nums[i] > target,则 target 只可能在下标 i 的左侧
  • 假如 nums[i] < target,则 target 只可能在下标 i 的右侧

二分查找的做法是,界说查找的规模[left,right],初始查找规模是整个数组。每次取查找规模的中点 mid,比较 nums[mid]target 的巨细,假如持平则 mid 即为要寻找的下标,假如不持平则依据 nums[mid]target 的巨细关系将查找规模缩小一半。

由于每次查找都会将查找规模缩小一半,因而二分查找的时刻复杂度是 O(logn),其间n是数组的长度。

二分查找的条件是查找规模不为空,即 left ≤ right。假如 target 在数组中,二分查找能够保证找到 target,回来 target 在数组中的下标。假如 target 不在数组中,则当 left > right 时结束查找,回来 -1。

# l, r 分别为左右指针
while l <= r:
    # 不运用 mid = (r + l) / 2 是为了避免数据类型溢出而导致的非预期
    mid = (r - l) / 2 + l
    if target == nums[mid]:
        return
    elif target > nums[mid]:
        l = mid + 1
    elif target < nums[mid]:
        r = mid - 1
return -1

解题

Python:

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

Java:

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

278. 第一个过错的版别

标题

278. 第一个过错的版别 难度:easy

你是产品司理,现在正在带领一个团队开发新的产品。不幸的是,你的产品的最新版别没有经过质量检测。由于每个版别都是根据之前的版别开发的,所以过错的版别之后的一切版别都是错的。

假定你有n个版别[1, 2, ..., n],你想找出导致之后一切版别犯错的第一个过错的版别。

你能够经过调用bool isBadVersion(version)接口来判断版别号 version是否在单元测验中犯错。实现一个函数来查找第一个过错的版别。你应该尽量减少对调用 API 的次数。

示例 1:

输入:n = 5, bad = 4
输出:4
解说:
调用 isBadVersion(3) -> false 
调用 isBadVersion(5)-> true 
调用 isBadVersion(4)-> true
所以,4 是第一个过错的版别。

示例 2:

输入: n = 1, bad = 1
输出: 1

提示:

  • 1 <= bad <= n <= 231- 1

办法一:二分查找

思路

依据题意显然是个二分查找,把版别号看成是有序的数组,经过二分查找进行版别测验,假如当前版别经过 API 测验是过错的,那就往前找,一直要找到第一个过错版别为止,因而,这个就是一个变种的二分查找,即查找第一个值等于给定值

这个一百个人有一百种写法,重在了解:

# n 为数组长度, nums 为数组
low, high = 0, n-1
while low <= high:
    mid = low + ((high - low) >> 1)
    if nums[mid] > value:
        high = mid - 1
    elif nums[mid] < value:
        low = mid + 1
    else:
        if (mid == 0) or (nums[mid-1] != value): return mid
        else: high = mid - 1
return -1

解题

Python:

class Solution:
    def firstBadVersion(self, n):
        l, r = 1, n
        while l < r:
            mid = l + r >> 1
            if isBadVersion(mid):
                r = mid
            else:
                l = mid + 1
        return l

Java:

public class Solution extends VersionControl {
    public int firstBadVersion(int n) {
        int left = 1, right = n;
        while (left < right) { // 循环直至区间左右端点相同
            int mid = left + (right - left) / 2; // 避免核算时溢出
            if (isBadVersion(mid)) {
                right = mid; // 答案在区间 [left, mid] 中
            } else {
                left = mid + 1; // 答案在区间 [mid+1, right] 中
            }
        }
        // 此刻有 left == right,区间缩为一个点,即为答案
        return left;
    }
}

跋文

以上就是 【算法题解】 Day8 二分查找 的一切内容了,创造不易,多多支持

我是 ,期待你的重视

系列专栏: 算法题解