LeetCode算法笔记【第一章：算法入门与数组篇】

最新推荐文章于 2025-11-24 15:27:16 发布

原创最新推荐文章于 2025-11-24 15:27:16 发布 · 141 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #leetcode #笔记

本文详细介绍了二分查找算法，包括其基本概念、步骤、细节以及不同情况下的处理，如区间开闭问题、mid值计算和出界条件判断。同时给出了多种搜索策略的代码示例，适用于简单和复杂问题的解决。

03数组二分查找

（1）知识（一）

1、二分查找算法介绍

1.1二分查找算法简介

又称为折半查找，通过不断缩小查找范围来加快查找效率，是一种效率较高的查找方法。

1.2二分查找算法步骤

1、使数组按顺序排列；

2、取出数组的查找范围；

3、计算中间元素mid

4、用mid与指定元素比较

5、修改左右范围

6、重复上述步骤，直到找到指定元素

1.3.二分查找算法思想

二分算法思想是将数组划分为两个部分，然后确定目标值可能存在的部分，去掉不存在的区间并继续划分，直到找到目标值或确定不存在。而对于有限规模的数组，经过有限次的查找，最终会查找到目标元素或者查找失败。

2、简单二分查找

题目大意

给定一个升序的数组 nums（nums 中的所有元素不重复），和一个目标值 target。

返回 target 在数组中的位置，如果找不到，则返回 −1。

如：

nums = [-1,0,3,5,9,12], target = 9

输出: 4 （9 出现在 nums 中并且下标为 4）

nums = [-1,0,3,5,9,12], target = 2

输出: -1 （ nums中没有2，返回 -1）

解题思路

1、设定范围：left = 0，right = len(nums)-1

2、计算mid：mid = (left+right)//2

3、比较mid与target：

如果 target==nums[mid]，则返回中心位置。

如果 target>nums[mid]，则将左节点设置为 mid+1，然后继续在右区间 [mid+1,right] 搜索。

如果 target<nums[mid]，则将右节点设置为 mid−1，然后继续在左区间 [left,mid−1] 搜索。

如果左边界大于右边界，查找范围缩小为空，说明目标元素不存在，此时返回 −1。

4、重复步骤2、3

代码


nums = [-1,0,3,5,9,12]
target = 9

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

（2）知识（二）

1、二分查找细节

区间开闭问题

左闭右闭：left=0，right=len(nums)-1, 访问区间： [ left， right ]

左闭右开：left=0,right=len(nums),访问区间：[left，right)

左闭右开区间算法复杂度大于左闭右闭区间，一般情况下推荐使用左闭右闭区间

mid的取值问题

常见的 mid 取值公式有两个：

mid = (left + right) // 2 或 mid = left + (right - left) // 2

mid = (left + right + 1) // 2 或 mid = left + (right - left + 1) // 2

后面的写法，在 left+right 的数据量可能会超过整型变量最大值时，可避免出错

出界条件的判断

出界条件一般有两种：left<right 、 left<=right

left<=right：

当查找的元素不在数组中时，while出界条件为left>right，查找区间为空，可直接返回-1

left<right ：

当查找的元素不在数组中时，while出界条件为left=right，查找区间剩余下标为left的元素，需要判断该元素是否是查找元素后才能返回-1

搜索区间范围的选择

在进行区间范围选择的时候，有三种选择方法：

left = mid + 1，right = mid - 1

left = mid + 1 ，right = mid

left = mid，right = mid - 1

2、二分查找思路

直接法

思想：找到指定元素直接返回结果

思路：设定边界 left=0，right=len(nums)−1，则待查找区间为 [left,right]

在循环条件 left <= right下进行判断：

求出 mid，比较 nums[mid] 与目标值 target 的大小

如果 target==nums[mid]，则返回mid。

如果 target>nums[mid]，则将左节点设置为 mid+1，然后继续在区间 [mid+1,right] 搜索。

如果 target<nums[mid]，则将右节点设置为 mid−1，然后继续在区间 [left,mid−1] 搜索。

如果左边界大于右边界，查找范围缩小为空，说明目标元素不存在，此时返回 −1。

排除法

思想：排除元素不存在区间

设定边界即 left=0，right=len(nums)−1，则查找区间为 [left,right]

算出 mid，比较目标元素和nums[mid]的大小，去除元素不存在的区间。

在剩余区间继续查找元素，继续去除无关区间

直到区间中只剩下最后一个元素，然后再判断这个元素是否是目标元素。

代码实现：

nums = [-1,0,3,5,9,12]
def search(nums,target):
    left, right = 0, len(nums) - 1
    while left < right:
        mid = ( left +  left) // 2
        if nums[mid] < target:
            left = mid + 1 
        else:
            right = mid
    return left if nums[left] == target else -1
print(search(nums,5))

适用范围

直接法：这种思路适合解决简单题目。即要查找的元素性质简单，数组中都是非重复元素。

排除法：适合解决复杂题目。比如查找一个数组里可能不存在的元素，找边界问题，可以使用这种思路。

（3）练习题目

1、二分查找

题目：
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

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

最少代码算法：

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        return nums.index(target) if target in nums else -1

2、搜索插入位置

题目：给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

class Solution(object):
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        right = len(nums)-1 
        left = 0
        while left<=right:
            mid = (right+left)//2
            if nums[mid]<target:
                left = mid+1
            else:
                right=mid-1
        return left

3、猜数字大小

题目：给定一个整数 n 和一个接口 def guess(num)，从 1∼n 中随机选取一个数 x。通过调用接口来判断自己猜测的数是否正确。返回题目选取的数字 x。

# The guess API is already defined for you.
# @param num, your guess
# @return -1 if num is higher than the picked number
#          1 if num is lower than the picked number
#          otherwise return 0
# def guess(num):
def guess(num):
    pick = 5
    if pick < num:
        return -1
    elif pick==num:
        return 0
    else :
        return 1
class Solution(object):
    def guessNumber(self, n):
        """
        :type n: int
        :rtype: int
        """
        left = 1
        right = n
        while left<=right:
            mid = (right+left)//2
            if guess(mid)==0:
                return mid
            elif guess(mid)==1:
                left=mid+1
            else :
                right=mid-1
        return left

4、X的平方根

题目：实现 int sqrt(int x) 函数。计算并返回 x 的平方根（只保留整数部分），其中 x 是非负整数。

class Solution(object):
    def mySqrt(self, x):
        """
        :type x: int
        :rtype: int
        """
        left = 0
        right = x//2
        num=0
        if x==1:
            return 1
        while left<=right:
            mid=(left+right)//2
            if mid*mid<=x:
                num = mid
                left = mid+1
            else :
                right=mid-1
        return num

5、两数之和Ⅱ — 输入有序数组

题目：

给定一个下标从 1 开始计数、升序排列的整数数组：numbers 和一个目标值 target。

从数组中找出满足相加之和等于 target 的两个数，并返回两个数在数组中下的标值。

class Solution(object):
    def twoSum(self, numbers, target):
        """
        :type numbers: List[int]
        :type target: int
        :rtype: List[int]
        """
        l = len(numbers)
        for i in range(l):
            left = i+1
            right = l-1
            while left<=right:
                mid = (left+right)//2
                if numbers[mid]+numbers[i]==target:
                    return [i+1,mid+1]
                elif numbers[mid]+numbers[i]>target:
                    right = mid-1
                else:
                    left=mid+1
        return [-1,-1]

6、在D天内送达包裹的能力

题目：

传送带上的包裹必须在 D 天内从一个港口运送到另一个港口。给定所有包裹的重量数组 weights，货物必须按照给定的顺序装运。且每天船上装载的重量不会超过船的最大运载重量，求能在 D 天内将所有包裹送达的船的最低运载量。

class Solution(object):

    def day(self,weights,mid):
        my_sum=0
        my_day=1
        for i in weights:
            if my_sum+i>mid:
                my_day+=1
                my_sum=0
            my_sum+=i
        return my_day            
    def shipWithinDays(self, weights, days):
        """
        :type weights: List[int]
        :type days: int
        :rtype: int
        """
        left = max(weights)
        right = sum(weights)
        while left<right:
            mid = (left+right)//2
            if self.day(weights,mid)>days:
                left = mid+1
            else :
                right = mid
        return left

7、第一个错误的版本

题目：

给你一个整数 n，代表已经发布的版本号。还有一个用于检测版本是否出错的接口：

isBadVersion(version): ，找出第一次出错的版本号 bad。

# The isBadVersion API is already defined for you.
# @param version, an integer
# @return a bool
# def isBadVersion(version):

class Solution(object):
    def firstBadVersion(self, n):
        """
        :type n: int
        :rtype: int
        """
        left = 1
        right = n
        while left <= right:
            mid = (left+right)//2
            if  isBadVersion(mid):
                right = mid-1
            else :
                left = mid+1
        return left

8、搜索旋转排序数组

题目：

给定一个整数数组 nums，数组中值互不相同。给定的 nums 是经过升序排列后的又进行了「旋转」操作的。再给定一个整数 target。从 nums 中找到 target 所在位置，如果找到，则返回对应下标，找不到则返回 −1。

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

9、寻找旋转排序数组的最小值

题目：给定一个数组 nums，nums 是有升序数组经过「旋转」得到的。但是旋转次数未知。数组中不存在重复元素。找出数组中的最小元素。

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