Binary Search on Hang Zhang

Koko Eating Bananas

Mon, 06 Jan 2025 00:00:00 +0000

875. 爱吃香蕉的珂珂

分析

定义区间：
- 吃香蕉速度的下界 l 为 1（最低速度）
- 吃香蕉速度的上界 r 为 10^9（最大速度，假设所有香蕉都在一堆中且时间充足）
判断函数 getTime(piles, k) ：
- 计算以速度 k 吃完所有香蕉需要的时间
- 遍历每堆香蕉 pile ，需要的时间为 pile / k 上取整，可以通过 (pile + k - 1) / k 实现
二分查找：
- 计算中间值 mid = (l + r) / 2 ：
  - 如果 getTime(piles, mid) <= h ，说明速度 mid 可以满足要求，但可能还有更小的速度满足条件，因此缩小上界 r = mid
  - 如果 getTime(piles, mid)} > h ，说明速度 mid 不够快，需要增大速度，更新下界 l = mid + 1
结束条件：
- 当 l == r 时，搜索范围缩小到单一值，返回 l 或 r 即为最小速度

时间复杂度

二分查找最多进行 O(log(10^9)) 次
每次计算 getTime(piles, k) 需要 O(n)，其中 n 是香蕉堆的数量

总复杂度为 O(n * log(10^9))

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
             {
public:
    // 判断以速度 k 吃完所有香蕉需要的时间
    int getTime(std::vector<int>& piles, int k)
    {
        int res = 0;
        for (int pile : piles)
            res += (pile + k - 1) / k; // 等价于 ceil(pile / k)
        return res;
    }

    int minEatingSpeed(vector<int>& piles, int h)
    {
        int l = 1, r = 1e9; // 定义速度的搜索区间
        while (l < r)
        {
            int mid = (l + r) >> 1;
            if (getTime(piles, mid) <= h) // 如果当前速度满足条件
                r = mid; // 尝试更小的速度
            else
                l = mid + 1; // 增大速度
        }
        return r; // 返回最小速度
    }
};

Find Peak Element

Sun, 05 Jan 2025 00:00:00 +0000

162. 寻找峰值

分析

定义区间：
- 使用两个指针 l 和 r，分别指向数组的起点和终点，表示当前搜索的范围
二分查找：
- 计算中间位置 mid = (l + r) / 2
- 比较 nums[mid] 和 nums[mid + 1] ：
  - 如果 nums[mid] > nums[mid + 1] ：说明峰值可能在左侧（包括当前 mid），将右边界 r 移到 mid
  - 如果 nums[mid] < nums[mid + 1] ：说明峰值可能在右侧，更新左边界 l 为 mid + 1
结束条件：
- 当 l == r 时，区间缩小为一个位置，此时该位置即为峰值索引

时间复杂度

时间复杂度 O(logn)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int findPeakElement(vector<int>& nums)
    {
        int l = 0, r = nums.size() - 1;
        while (l < r) {
            int mid = (l + r) >> 1;
            if (nums[mid] > nums[mid + 1])
                r = mid; // 峰值在左侧或当前 mid
            else
                l = mid + 1; // 峰值在右侧
        }
        return r; // 或返回 l，最终 l == r
    }
};

Guess Number Higher Or Lower

Sun, 05 Jan 2025 00:00:00 +0000

374. 猜数字大小

分析

初始化搜索范围：
- 定义变量 l 和 r 分别表示搜索范围的左右边界
- 初始搜索范围为 [1, n]
二分查找：
- 计算中间值 mid = (l + r) / 2，避免溢出可以写为 (l + r) >> 1
- 调用 guess(mid) 判断中间值与目标值的关系：
- 如果返回 -1，说明目标值更小，将右边界缩小为 r = mid
- 如果返回 1，说明目标值更大，将左边界缩小为 l = mid + 1
终止条件：
- 当左右边界相遇时，搜索结束，返回 r

时间复杂度

每次查找都会将搜索范围缩小一半，直到范围缩小到 1

时间复杂度为 O(logn)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int guessNumber(int n)
    {
        int l = 1, r = n; // 初始化左右边界
        while (l < r)
        {
            int mid = (long long)l + r >> 1; // 计算中间值
            if (guess(mid) <= 0) // 若目标值小于等于 mid
                r = mid; // 缩小右边界
            else // 若目标值大于 mid
                l = mid + 1; // 缩小左边界
        }
        return r; // 返回结果
    }
};

Successful Pairs Of Spells And Potions

Sun, 05 Jan 2025 00:00:00 +0000

2300. 咒语和药水的成功对数

分析

排序药水数组：
- 为了快速确定满足条件的药水，我们对药水数组 potions 进行升序排序
二分查找：
- 对于每个咒语 spells[i]，计算所需药水的最小能量值：target = (success + spells[i] - 1) / spells[i]
- 使用二分查找找到第一个大于等于 target 的药水位置 pos
- 满足条件的药水数量为 m - pos，其中 m 是药水数组的长度
返回结果：
- 对每个咒语计算成功组合的药水数量，并存储在结果数组 res 中

时间复杂度

药水数组排序：O(mlogm)
对每个咒语进行二分查找：O(nlogm)

总时间复杂度：O(mlogm + nlogm)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution {
public:
    // 二分查找：找到第一个大于等于 target 的药水位置
    int search(std::vector<int>& potions, long long target)
    {
        int l = 0, r = potions.size();
        while (l < r)
        {
            int mid = (l + r) >> 1;
            if (potions[mid] >= target)
                r = mid;
            else
                l = mid + 1;
        }
        return r;
    }

    vector<int> successfulPairs(vector<int>& spells, vector<int>& potions, long long success)
    {
        int n = spells.size(), m = potions.size();
        std::sort(potions.begin(), potions.end()); // 排序药水数组
        std::vector<int> res(n);
        for (int i = 0; i < n; ++i)
        {
            // 计算当前咒语的 target 值
            int pos = search(potions, (success + spells[i] - 1) / spells[i]);
            res[i] = m - pos; // 成功组合数量
        }
        return res;
    }
};

Longest Increasing Subsequence

Wed, 11 Dec 2024 00:00:00 +0000

300. 最长递增子序列

分析

思路
- 使用一个数组 q 来维护当前已知的递增子序列。这个数组不一定是真实的子序列，而是用于动态记录递增子序列的长度信息
- 遍历数组 nums 时，依次将当前数字插入到 q 中，保证 q 中的元素始终满足递增条件
处理策略：
- 如果当前数字 x 大于 q 的最后一个元素，则直接追加到 q 的末尾
- 否则，使用二分查找找到 q 中第一个大于或等于 x 的位置，并用 x 替换该位置的值这相当于更新子序列，使其在同样长度的情况下更容易扩展
返回结果：
- 最终数组 q 的长度即为最长递增子序列的长度

时间复杂度

遍历数组时，每个元素需要执行一次二分查找，二分查找的复杂度为 O(logn)

总时间复杂度 O(nlogn)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int lengthOfLIS(vector<int>& nums)
    {
        std::vector<int> q;  // 用于记录递增子序列的数组
        for (int x : nums)
        {
            if (q.empty() || x > q.back())  // 如果当前数字大于子序列末尾元素
                q.push_back(x);  // 直接追加
            else
            {
                // 使用二分查找定位
                int l = 0, r = q.size() - 1;
                while (l < r)
                {
                    int mid = (l + r) >> 1;  // 中间位置
                    if (x <= q[mid])  // 如果当前数字小于等于 q[mid]
                        r = mid;  // 缩小右边界
                    else
                        l = mid + 1;  // 缩小左边界
                }
                q[r] = x;  // 替换第一个大于等于 x 的位置
            }
        }
        return q.size();  // q 的长度即为最长递增子序列的长度
    }
};

Median of Two Sorted Arrays

Sat, 07 Dec 2024 00:00:00 +0000

4. 寻找两个正序数组的中位数

分析

采用二分查找的方法，避免直接合并数组：

总长度奇偶性判断：
- 如果两个数组合并后的长度为奇数，只需找到第 total / 2 + 1 小的数
- 如果为偶数，需找到第 total / 2 和第 total / 2 + 1 小的数，然后取平均值
递归查找第 k 小的数：
- 边界条件（递归终止条件）：
  - 如果一个数组为空，直接返回另一个数组中的第 k 小的数
  - 如果 k = 1，返回两个数组当前起点的较小值
- 二分递归：
  - 比较两个数组中第 k / 2 小的元素
  - 较小的那一部分不可能包含第 k 小的数，因此可以直接从数组中排除
  - 递归更新起始位置和 k 的值

时间复杂度

每次递归将搜索范围缩小一半，因此时间复杂度为 O(log(min(m, n)))

空间复杂度

空间复杂度为递归调用的栈空间，最大为 O(log(min(m, n)))

C++代码

class Solution
{
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2)
    {
        // 计算总长度
        int total = nums1.size() + nums2.size();

        // 如果总长度为偶数，需找到中间两个数并取平均值
        if (total % 2 == 0)
        {
            double left = find(nums1, 0, nums2, 0, total / 2);
            double right = find(nums1, 0, nums2, 0, total / 2 + 1);
            return (left + right) / 2;
        }

        // 如果总长度为奇数，找到中间的数
        return find(nums1, 0, nums2, 0, total / 2 + 1);
    }

    double find(std::vector<int>& nums1, int i, std::vector<int>& nums2, int j, int k)
    {
        // 让 nums1 始终是较短的数组
        if (nums1.size() - i > nums2.size() - j)
            return find(nums2, j, nums1, i, k);

        // 边界条件：nums1 已经为空
        if (nums1.size() - i == 0)
            return nums2[j + k - 1];

        // 边界条件：k = 1，直接返回两数组当前起点的较小值
        if (k == 1)
            return std::min(nums1[i], nums2[j]);

        // 二分查找
        int mid1 = std::min((int)nums1.size() - 1, i + k / 2 - 1);
        int mid2 = j + k / 2 - 1;

        if (nums1[mid1] > nums2[mid2])
            // 排除 nums2 前 (mid2 - j + 1) 个元素
            return find(nums1, i, nums2, mid2 + 1, k - (mid2 - j + 1));
        else
            // 排除 nums1 前 (mid1 - i + 1) 个元素
            return find(nums1, mid1 + 1, nums2, j, k - (mid1 - i + 1));
    }
};

Find First and Last Postion of Element In Sorted Array

Fri, 06 Dec 2024 00:00:00 +0000

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

分析

寻找左边界：
- 目标是找到 target 在数组中的最左侧位置
  - 每次检查 nums[mid]是否大于等于 target
  - 如果是，则缩小右边界 r = mid，以确保找到第一个出现的目标值
- 如果左边界不存在（即数组中没有 target），直接返回 [-1, -1]
寻找右边界：
- 目标是找到 target 在数组中的最右侧位置
  - 每次检查 nums[mid] 是否小于等于 target
  - 如果是，则缩小左边界 l = mid，确保找到最后一个出现的目标值
- 只有在左边界存在时，才会继续找右边界

时间复杂度

每次二分查找的时间复杂度为 O(log n)，总共两次，因此时间复杂度为 O(log n)

空间复杂度

空间复杂度为 O(1)

C++代码

vector<int> searchRange(vector<int>& nums, int target)
{
  // 如果数组为空，直接返回
  if (nums.empty())
    return {-1, -1};

  // 第一次二分查找左边界
  int l = 0, r = nums.size() - 1;
  while (l < r)
  {
    int mid = (l + r) >> 1;  // 中间位置
    if (target <= nums[mid])
      r = mid;  // 缩小右边界
    else
      l = mid + 1;  // 缩小左边界
  }

  // 检查左边界是否存在
  if (nums[r] != target)
    return {-1, -1};
  int L = r;  // 记录左边界

  // 第二次二分查找右边界
  l = 0, r = nums.size() - 1;
  while (l < r)
  {
    int mid = (l + r + 1) >> 1;  // 中间位置，偏向右
    if (target >= nums[mid])
      l = mid;  // 缩小左边界
    else
      r = mid - 1;  // 缩小右边界
  }

  // 返回左右边界
  return {L, r};
}

Find Minimum in Rotated Sorted Array

Fri, 06 Dec 2024 00:00:00 +0000

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

分析

未旋转情况：
- 如果数组的首元素小于尾元素，说明数组未旋转，直接返回 nums[0]
二分查找旋转点：
- 在旋转数组中，最小值位于右部分的起点。
- 使用二分查找，通过比较 nums[mid] 和 nums[0] 的值，可以判断最小值的所在位置：
  - 如果 nums[mid] >= nums[0]，说明最小值在右侧，缩小左边界
  - 如果 nums[mid] < nums[0]，说明最小值在左侧或当前 mid 是最小值，缩小右边界
- 最终，r + 1 指向最小值的位置

时间复杂度

二分查找的时间复杂度为 O(logn)

空间复杂度

使用常量级额外空间，空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int findMin(vector<int>& nums)
    {
        int n = nums.size();
        // 如果数组未旋转，直接返回首元素
        if (nums[0] <= nums[n - 1])
            return nums[0];

        int l = 0, r = n - 1;
        while (l < r)
        {
            int mid = (l + r + 1) >> 1; // 取中间值
            if (nums[0] <= nums[mid])
                l = mid; // 最小值在右侧
            else
                r = mid - 1; // 最小值在左侧
        }
        return nums[r + 1]; // 返回最小值
    }
};

Search Insert Position

Fri, 06 Dec 2024 00:00:00 +0000

35. 搜索插入位置

分析

定义搜索范围：
- 使用两个指针 l 和 r 分别表示数组的左边界和右边界，初始值为 0 和 nums.size()
- 注意右边界初始值为 nums.size()，因为我们需要处理目标值可能插入在数组末尾的情况
进行二分查找：
- 计算中间位置 mid = (l + r) >> 1
- 如果 target <= nums[mid]：
  - target 可能在 mid 位置或其左侧，更新右边界 r = mid
- 如果 target > nums[mid]：
  - target 一定在 mid 右侧，更新左边界 l = mid + 1
返回结果：
- 最终，l 和 r 会收敛到目标值的位置
- 如果 target 不在数组中，返回的是它应该插入的位置

时间复杂度

二分查找的时间复杂度为 O(log n)，其中 n 是数组长度

空间复杂度

空间复杂度为 O(1)

C++代码

int searchInsert(vector<int>& nums, int target)
{
  int l = 0, r = nums.size();
  while (l < r)  // 当左边界小于右边界时，继续搜索
  {
    int mid = (l + r) >> 1;  // 计算中点
    if (target <= nums[mid])
      r = mid;  // 缩小右边界，可能找到目标或插入点
    else
      l = mid + 1;  // 缩小左边界
  }
  return r;  // 返回插入位置
}

search2dMatrix

Thu, 28 Nov 2024 00:00:00 +0000

74. 搜索二维矩阵

分析

由于矩阵按行列有序，可以将整个二维矩阵视为一个长度为 n * m 的一维数组，并在这个一维数组上进行二分查找

矩阵映射为一维数组：
- 矩阵的第 i 行和第 j 列的元素 matrix[i][j]，在一维数组中对应的索引为 i * m + j
- 反之，一维数组的索引 k 对应矩阵中的元素为 matrix[k / m][k % m]
二分查找：
- 初始时，定义查找区间的左右端点为 l = 0 和 r = m * n - 1
- 每次取中点 mid，将其映射到二维矩阵元素 matrix[mid / m][mid % m] ，与 target 比较：
  - 若该值大于等于 target，收缩右边界 r = mid
  - 若该值小于 target，收缩左边界 l = mid + 1
- 循环结束时，检查索引 r 对应的矩阵元素是否等于 target

时间复杂度

每次二分查找都会将查找范围缩小为原来的一半，总体复杂度为 O(log(m * n))

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target)
    {
        int n = matrix.size(), m = matrix[0].size(); // 矩阵行数和列数
        int l = 0, r = n * m - 1; // 二分区间 [l, r]
        while (l < r)
        {
            int mid = (l + r) >> 1; // 中点
            if (target <= matrix[mid / m][mid % m])
                r = mid; // 收缩右边界
            else
                l = mid + 1; // 收缩左边界
        }
        // 判断最终位置是否是目标值
        return matrix[r / m][r % m] == target;
    }
};

Search in Rotated Sorted Array

Wed, 03 Apr 2024 00:00:00 +0000

33. Search in Rotated Sorted Array

分析

找旋转点：
- 通过二分查找，判断 nums[mid] 和 nums[0] 的关系：
  - 如果 nums[mid] >= nums[0]，说明 mid 在前半部分，继续搜索右侧
  - 否则，说明 mid 在后半部分，继续搜索左侧
- 最终 r 指向旋转点前的最后一个位置
确定搜索范围：
- 如果 target >= nums[0]，说明目标值在前半部分，设置 l = 0
- 否则，目标值在后半部分，设置 l = r + 1，r = nums.size() - 1
二分查找目标值：
- 普通的二分查找，最终检查 nums[r] 是否等于目标值

时间复杂度

找旋转点和目标值各需要一次二分查找，每次的时间复杂度为 O(log n)

总体时间复杂度为 O(log n)

空间复杂度

使用常量级别额外空间，空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int search(vector<int>& nums, int target)
    {
      if (nums.empty())  // 特殊情况：数组为空
        return -1;

      // 第一次二分查找：找到旋转点
      int l = 0, r = nums.size() - 1;
      while (l < r)
      {
        int mid = (l + r + 1) >> 1;  // 偏向右侧
        if (nums[0] <= nums[mid])
          l = mid;  // 旋转点在右侧
        else
          r = mid - 1;  // 旋转点在左侧
      }

      // 确定搜索范围
      if (target >= nums[0])  // 目标值在前半部分
        l = 0;
      else  // 目标值在后半部分
      {
        l = r + 1;
        r = nums.size() - 1;
      }


      // 第二次二分查找：找到目标值
      while (l < r)
      {
        int mid = (l + r) >> 1;
        if (target <= nums[mid])
          r = mid;  // 收缩右边界
        else
          l = mid + 1;  // 收缩左边界
      }

      // 检查是否找到目标值
      if (target == nums[r])
        return r;
      return -1;
    }
};