2023-06-06 15:11阅读: 19评论: 0推荐: 0

二分搜索的应用

简介

应用

典型应用如下：

序号	题目
1	33. 搜索旋转排序数组
2	81. 搜索旋转排序数组 II
3	378. 有序矩阵中第 K 小的元素
4	373. 查找和最小的 K 对数字
5	719. 找出第 K 小的数对距离

应用1：Leetcode 33. 搜索旋转排序数组

题目

33. 搜索旋转排序数组

分析

方法一

旋转后的数组，就形成了两个有序的子数组。

因为左右两部分子数组都是有序的，所以，在局部查找的时候，依然可以使用二分查找的方式查找。

算法步骤

对于每次找到的区间中点 nums[mid] ：

如果它在右侧的子区间
- 如果目标值 target 在 [nums[0], nums[mid]]之间，则移动区间右侧的指针；
- 否则，就移动区间左侧指针。
如果它在左侧的子区间
- 如果目标值 target 在 [nums[mid], nums[-1]]之间，则移动区间右侧的指针；
- 否则，就移动区间左侧指针。

方法二

比较直观的思路是：因为目标值 target 是固定的，所以，我们直接考虑 target 落在左侧子区间，还是右侧子区间。

算法步骤

对于待查找的目标值 target ：

如果它落在右侧的子区间
- 如果区间中点nums[mid] 大于目标值 target，或者区间中点 nums[mid] 小于 nums[0]，则移动右侧指针；
- 否则就移动左侧指针。
如果它落在左侧的子区间
- 如果区间中点nums[mid] 小于目标值 target，或者区间中点 nums[mid] 大于等于 nums[0]，则移动左侧指针；
- 否则就移动右侧指针。

代码实现

方法一

 class Solution:
    def search(self, nums: List[int], target: int) -> int:
        if not nums:
            return -1
 
        left, right = 0, len(nums) - 1
        while left <= right:
            mid = left + (right - left) // 2
 
            if nums[mid] == target:
                return mid
 
            if nums[0] <= nums[mid]:
                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

方法二

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

应用2：Leetcode 81. 搜索旋转排序数组 II

题目

81. 搜索旋转排序数组 II

分析

当数组中存在重复元素时，二分查找时，可能会遇到这种情况：

n u m s [l e f t] = n u m s [m i d] = n u m s [r i g h t]

此时，无法判断区间应该在左侧，还是右侧缩小。

例如， $n u m s = [3, 1, 2, 3, 3, 3, 3, 3], t a r g e t = 2$ ，第一次二分时，区间中点： $n u m s [3] = 3$ ，区间被分成两个子区间： $n u m s [0 \dots 2] = [3, 1, 2]$ ， $n u m s [4 \dots 7] = [3, 3, 3, 3]$ ，此时，区间中点元素 $3$ 与左右边界元素相同。

这种情况，只需要同时缩小左右两侧的边界即可，即左边界加 1，右边界减 1，然后在新的区间上继续二分查找即可。

代码实现

 class Solution:
    def search(self, nums: List[int], target: int) -> bool:
        n = len(nums)
        if not nums:
            return False
 
        if n == 1:
            return nums[0] == target
 
        left, right = 0, len(nums) - 1
        while left <= right:
            mid = left + (right - left) // 2
            if nums[mid] == target:
                return True
 
            # 左右两侧元素，与区间中点元素相等，则同时移动左右指针
            if nums[left] == nums[mid] and nums[right] == nums[mid]:
                left += 1
                right -= 1
            elif nums[left] <= nums[mid]:
                if nums[left] <= target < nums[mid]:
                    right = mid - 1
                else:
                    left = mid + 1
            else:
                if nums[mid] < target <= nums[-1]:
                    left = mid + 1
                else:
                    right = mid - 1
 
        return False

应用3：Leetcode 378. 有序矩阵中第 K 小的元素

题目

378. 有序矩阵中第 K 小的元素

给你一个 n x n 矩阵 matrix ，其中每行和每列元素均按升序排序，找到矩阵中第 k 小的元素。
请注意，它是排序后的第 k 小元素，而不是第 k 个不同的元素。
你必须找到一个内存复杂度优于 $O (n^{2})$ 的解决方案。

示例：

输入： $m a t r i x = [[1, 5, 9], [10, 11, 13], [12, 13, 15]]$ , $k = 8$
输出： $13$
解释：矩阵中的元素为 $[1, 5, 9, 10, 11, 12, 13, 13, 15]$ ，第 $8$ 小元素是 $13$

分析

方法一：二分查找

矩阵中最小的元素是 $m a t r i x [0] [0]$ ，最大的元素是 $m a t r i x [- 1] [- 1]$ ，并且在矩阵中的每一行和每一列都是有序的。

我们假设第 $k$ 小元素是 $t a r g e t$ ，那么， $t a r g e t$ 一定满足：

m a t r i x [0] [0] <= t a r g e t <= m a t r i x [- 1] [- 1]

因此，我们可以定一个查找区间 $[l e f t, r i g h t] = [m a t r i x [0] [0], m a t r i x [- 1] [- 1]]$ ，查找的目标值 $t a r g e t$ 只需要满足它是排序之后的第 $k$ 小元素即可。

这样，我们就可以，通过二分法，查找区间 $[l e f t, r i g h t]$ 内的所有数值。

对于排序之后的第 $k$ 小元素，我们可以利用矩阵每行每列都是有序的性质，从矩阵左下角，寻找一条到右上角的路线，并通过计算路线左上半部分的区域的元素个数，从而判断区间中点是否满足它是第 $k$ 小元素的条件。

对于区间内的中间值 $m i d$ ，左右区间缩小的判断条件是：

从左下往右上移动
- 如果遇到矩阵中元素大于 $m i d$ ，则向右移动；
- 如果遇到矩阵中元素小于 $m i d$ ，则向上移动；
统计矩阵中，左上部分的元素个数
- 如果左上部分的元素个数大于 $k$ ，则说明 $m i d$ 较大，需要移动区间右侧指针；
- 如果左上部分的元素个数小于 $k$ ，则说明 $m i d$ 较小，需要移动区间左侧指针；

方法二：归并排序

将矩阵中的每一行的第一个元素及其坐标压入优先级队列（小根堆），每次弹出一个元素，同时，将该行下一个元素及其坐标压入优先级队列，进行 $k - 1$ 次之后，第 $k$ 次弹出的元素，就是第 $k$ 小的元素。

代码实现

方法一

 class Solution:
    def kthSmallest(self, matrix: List[List[int]], k: int) -> int:
        n = len(matrix)
        left, right = matrix[0][0], matrix[-1][-1]
        while left < right:
            mid = (left + right) // 2
            if self.check(mid, matrix, k):
                right = mid
            else:
                left = mid + 1
                return left
 
    @classmethod
    def check(cls, mid, matrix, k):
        n = len(matrix)
        # 左下角的坐标
        i, j = n - 1, 0
        num = 0
        # 坐标在矩阵内部可以移动的路线，根据移动的路线，计算左侧元素数量
        while i >= 0 and j < n:
            # 如果当前元素小于mid, 指针向右移动
            if matrix[i][j] <= mid:
                num += i + 1
                j += 1
            # 如果当前元素大于mid，指针向上移动
            else:
                i -= 1
        # 左侧元素的个数大于k，则移动right指针，反之，移动left
        return num >= k

方法二

 class Solution:
    def kthSmallest(self, matrix: List[List[int]], k: int) -> int:
        n = len(matrix)
        # 取出矩阵第一列
        queue = [(matrix[i][0], i, 0) for i in range(n)]
        heapq.heapify(queue)
 
        for i in range(k - 1):
            num, x, y = heapq.heappop(queue)
            if y != n - 1:
                heapq.heappush(queue, (matrix[x][y + 1], x, y + 1))
 
        num, _, _ = heapq.heappop(queue)
        return num

应用4：Leetcode 373. 查找和最小的 K 对数字

题目

373. 查找和最小的 K 对数字

给定两个以升序排列的整数数组 $n u m s 1$ 和 $n u m s 2$ , 以及一个整数 $k$ 。
定义一对值 $(u, v)$ ，其中第一个元素来自 $n u m s 1$ ，第二个元素来自 $n u m s 2$ 。
请找到和最小的 $k$ 个数对 $(u_{1}, v_{1})$ , $(u_{2}, v_{2})$ , $\dots$ , $(u_{k}, v_{k})$ 。

示例：

输入: $n u m s 1 = [1, 1, 2]$ , $n u m s 2 = [1, 2, 3]$ , $k = 2$
输出: $[1, 1], [1, 1]$
解释: 返回序列中的前 2 对数： $[1, 1], [1, 1], [1, 2], [2, 1], [1, 2], [2, 2], [1, 3], [1, 3], [2, 3]$

分析

方法一：二分查找

与前面 378. 有序矩阵中第 K 小的元素的思路类似。

假设 $n u m s 1$ 与 $n u m s 2$ 中的元素个数分别为 $m$ , $n$ 。

算法步骤：

首先使用二分查找，找到第 $k$ 个数对的和 $p a i r S u m$ ，二分查找的思路如下：
- 查找区间： $[l e f t, r i g h t] = [n u m s 1 [0] + n u m s 2 [0], n u m s 1 [m - 1] + n u m s 2 [n - 1]]$ ；
- 查找条件：满足数对和小于 $k$ 的数对个数；
- 查找过程中，我们维护两个指针 $i$ , $j$ ，使 $i$ 顺序遍历 $n u m s 1$ ，使 $j$ 倒序遍历 $n u m s 2$ ：
  - 如果数对和小于区间中间值，则向右移动指针 $i$ ；
  - 如果数对和大于区间中间值，则向左移动指针 $j$ ；
然后，从小到大依次查找数对和小于 $p a i r S u m$ 的元素组合，并加入结果集 $r e s u l t$ ；
再记录数对和等于 $p a i r S u m$ 的元素组合，如果结果集 $r e s u l t$ 等于 $k$ ，则停止记录。

方法二：多路并归

假设 $n u m s 1$ 与 $n u m s 2$ 中的元素个数分别为 $m$ , $n$ 。

我们维护一个优先级队列，先将 $n u m s 2 [0]$ 与 $n u m s 1$ 中所有元素的组合之和及对应的元素序号，即

(n u m s 1 [0] + n u m s 2 [0], 0, 0), (n u m s 1 [1] + n u m s 2 [0], 1, 0), \dots, (n u m s 1 [m - 1] + n u m s 2 [0], m - 1, 0)

压入优先级队列。

遍历 $n u m s 2$ 中剩余元素，即可得到结果集。

算法步骤：

先将 $n u m s 2 [0]$ 与 $n u m s 1$ 中所有元素的组合之和及对应的元素序号压入优先级队列；
每次弹出堆顶的对象，并将元素组合加入结果集；
对于堆顶的对象的元素的序号组合 $(i, j)$ ：
- 如果 $n u m s 2 [j]$ 的下一个元素满足 $j + 1 < n$ ，就将 $n u m s 2$ 中的下一个元素压入优先级队列；
- 否则，就继续弹出堆中的剩余元素。
重复弹出 $k$ 次后，就得到和最小的 $k$ 个数对了。

代码实现

方法一

 class Solution:
    def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
from typing import List
 
 
class Solution:
    def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
        m, n = len(nums1), len(nums2)
        pair_sum = self.findKSmallest(nums1, nums2, k)
 
        result = []
        # 找数对和小于 pair_sum 的数对
        i = n - 1
        for _num in nums1:
            while i >= 0 and _num + nums2[i] >= pair_sum:
                i -= 1
            # 因为原数组是升序排列的，所以先顺序记录结果，保证小的结果在前面
            for j in range(i + 1):
                result.append([_num, nums2[j]])
 
        # 找数对和等于 pair_sum 的数对
        i = n - 1
        for _num in nums1:
            while i >= 0 and _num + nums2[i] > pair_sum:
                i -= 1
            # 只寻找数对和等于pair_sum的组合，所以倒序记录
            for j in range(i, -1, -1):
                if _num + nums2[j] == pair_sum:
                    result.append([_num, nums2[j]])
                    if len(result) == k:
                        return result
 
        return result
 
    def findKSmallest(self, nums1: List[int], nums2: List[int], k: int):
        """ 通过二分查找第 k 小的数对和 """
        m, n = len(nums1), len(nums2)
        # 查找区间
        left, right = nums1[0] + nums2[0], nums1[m - 1] + nums2[n - 1]
        while left < right:
            mid = (left + right) // 2
            if self._check(mid, nums1, nums2, k):
                left = mid + 1
            else:
                right = mid
        return left
 
    def _check(self, mid: int, nums1: List[int], nums2: List[int], k: int):
        m, n = len(nums1), len(nums2)
        count = 0
        # 使用两个指针i, j，使i顺序遍历nums1，使j倒序遍历nums2
        i, j = 0, n - 1
        while i < m and j >= 0:
            # 记录数对和小于mid的个数
            if nums1[i] + nums2[j] <= mid:
                count += j + 1
                i += 1
            else:
                j -= 1
        return count < k

方法二

 import heapq
from typing import List
 
 
class Solution:
    def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
        m, n = len(nums1), len(nums2)
        results = []
        pq = [(nums1[i] + nums2[0], i, 0) for i in range(min(k, m))]
        while pq and len(results) < k:
            _, i, j = heapq.heappop(pq)
            results.append([nums1[i], nums2[j]])
            if j + 1 < n:
                heapq.heappush(pq, (nums1[i] + nums2[j + 1], i, j + 1))
        return results

应用4：Leetcode 786. 第 K 个最小的素数分数

题目

786. 第 K 个最小的素数分数

给你一个按递增顺序排序的数组 $a r r$ 和一个整数 $k$ 。数组 $a r r$ 由 $1$ 和若干素数组成，且其中所有整数互不相同。
对于每对满足 $0 \leq i < j < a r r . l e n g t h$ 的 $i$ 和 $j$ ，可以得到分数 $\frac{a r r [i]}{a r r [j]}$ 。
那么第 $k$ 个最小的分数是多少呢? 以长度为 $2$ 的整数数组返回你的答案, 这里 $a n s w e r [0] == a r r [i]$ 且 $a n s w e r [1] == a r r [j]$ 。

示例 1：

输入： $a r r = [1, 2, 3, 5], k = 3$
输出： $[2, 5]$
解释：已构造好的分数,排序后如下所示: $1 / 5, 1 / 3, 2 / 5, 1 / 2, 3 / 5, 2 / 3$ ，很明显第三个最小的分数是 $2 / 5$

分析

方法一：二分查找

这里，我们假设第 $k$ 小的分数为 $x$ ，那么，对于任意两个元素 $a r r [i], a r r [j]$ 的组合，都可以得到分数 $\frac{a r r [i]}{a r r [j]}$ ，并且，它一定满足：

0 \leq \frac{a r r [i]}{a r r [j]} \leq 1

并且当分母固定时，由于分子是一个递增序列，所以，该分数序列也是递增序列，因此，这个分数序列满足二分查找的条件。

算法步骤：

在查找区间： $(0, 1)$ ，左右都是开区间
对区间进行折半查找，对于每一个区间的中点 $m i d$ ：
- 我们使用双指针的思路，维护两个指针 $i$ 、 $j$ ：使 $i$ 指向分子，使 $j$ 指向分母；
- 通过指针 $j$ 枚举所有的分母： $a r r [1], \dots, a r r [n - 1]$ ；
- 通过指针 $i$ 枚举所有的分子： $a r r [1], \dots, a r r [j - 1]$ ；
  
  为什么从 $1$ 开始枚举？
  
  因为，我们要求的是小于 $x$ 的分数组合，如果从零开始，即使 $\frac{a r r [0]}{a r r [j]} \leq x$ ，小于等于 $x$ 的分数组合是 $0$ 个，所以我们可以直接跳过这个组合。
- 对于任意一个分母 $a r r [j]$ ，指针 $i$ 会不断向右移动，并且，保证 $\frac{a r r [i]}{a r r [j]} \leq x$ 一直成立；
  
  当指针 $i$ 无法移动时，显然，数组的前 $i + 1$ 个元素： $a r r [0], \dots, a r r [i]$ 都可以作为分子，使得 $\frac{a r r [i]}{a r r [j]} \leq x$ 成立，但是， $a r r [i + 1]$ 及其之后的元素不能作为分子。
- 我们将所有分数值小于 $x$ 的组合个数累加起来，就得到小于 $x$ 的分数组合个数 $c o u n t$ ，同时，我们将恰好等于 $x$ 的元素组合也记录下来，用于最后的结果返回
区间缩小的策略，需要通过 $c o u n t$ 判断：
- 如果 $c o u n t \geq k$ , 则将右指针 $r i g h t$ 指向 $m i d$ ；
- 如果 $c o u n t < k$ , 则将左指针 $l e f t$ 指向 $m i d$ ；
当右指针 $r i g h t$ 和左指针 $l e f t$ 相等时，则结束查找。

方法二：多路并归

假设数组 $a r r$ 的长度为 $n$ ，当分母固定为某一个值 $a r r [j]$ 时，分子可以在 $a r r [0], \dots, a r r [j - 1]$ 中选择。

由于数组 $a r r$ 是严格递增，因此，序列

\frac{a r r [i]}{a r r [j]} = \frac{a r r [0]}{a r r [j]}, \dots, \frac{a r r [n - 1]}{a r r [j]}

也是严格递增的，这样的序列一共有 $n$ 组。

我们可以将这 $n$ 组序列，看成一个 $n$ 维矩阵。

初始条件，先将矩阵的第一列压入堆中，即将 $n - 1$ 个分子最小的序列压入堆中，即：

\frac{a r r [0]}{a r r [j]} = \frac{a r r [0]}{a r r [0]}, \dots, \frac{a r r [0]}{a r r [n - 1]}

每次从堆中弹出一个对象时，就将分子对应的元素后移一个位置，重复 $k - 1$ 次后，堆顶对应的元素，就是第 $k$ 小的分数。

代码实现

方法一

Java

 class Solution {
    double eps = 1e-8;
    int a, b;
    public int[] kthSmallestPrimeFraction(int[] arr, int k) {
        double left = 0, right = 1;
        while (right - left > eps) {
            double mid = (left + right) / 2;
            if (check(arr, mid) >= k) {
                right = mid;
            }
            else {
                left = mid;
            }
        }
 
        return new int[]{a, b};
    }
 
    int check(int[] array, double x){
        int count = 0;
        int i = 0;
        for (int j = 1; j < array.length; j++) {
            while (array[i + 1] * 1.0 / array[j] <= x) {
                i++;
            }
 
            if (array[i] * 1.0 / array[j] <= x) {
                count += i + 1;
            }
            // 记录分数值恰好等于 x 的元素组合
            if (Math.abs(array[i] * 1.0 / array[j] - x) < eps) {
                a = array[i];
                b = array[j];
            }
        }
        return count;
    }
}

Python

 from typing import List
 
EPS = 1e-8
 
 
class Solution:
    def kthSmallestPrimeFraction(self, arr: List[int], k: int) -> List[int]:
        a, b = 0, 0
        left, right = 0.0, 1.0
        while right - left > EPS:
            mid = left + (right - left) / 2
            result = self._check(arr, mid, k)
            if result[0]:
                right = mid
                a, b = result[1], result[2]
            else:
                left = mid
 
        return [a, b]
 
    def _check(self, array: List[int], x: float, k):
        count = 0
        i = 0
        a, b = 0, 0
        for j in range(1, len(array)):
            while array[i + 1] * 1.0 / array[j] <= x:
                i += 1
 
            if array[i] * 1.0 / array[j] <= x:
                count += i + 1
            # 记录分数值恰好等于 x 的元素组合
            if abs(array[i] * 1.0 / array[j] - x) < EPS:
                a = array[i]
                b = array[j]
        return count >= k, a, b

方法二

 import heapq
from typing import List
 
 
class Node(object):
    def __init__(self, index_x: int, index_y: int, x: int, y: int):
        """ x/y """
        self.index_x = index_x
        self.index_y = index_y
        self.x = x
        self.y = y
 
    def __lt__(self, other):
        return self.x * other.y < self.y * other.x
 
 
class Solution:
    def kthSmallestPrimeFraction(self, arr: List[int], k: int) -> List[int]:
        n = len(arr)
        pq = [Node(0, j, arr[0], arr[j]) for j in range(n)]
        heapq.heapify(pq)
 
        for _ in range(k - 1):
            node = heapq.heappop(pq)
            if node.index_x + 1 < n:
                next_node = Node(node.index_x + 1, node.index_y, arr[node.index_x + 1], node.y)
                heapq.heappush(pq, next_node)
        node = pq[0]
        return [node.x, node.y]

应用5：Leetcode 719. 找出第 K 小的数对距离

题目

719. 找出第 K 小的数对距离

分析

因为第 $k$ 小的数必然满足： $0 \leq k \leq max (n u m s) - min (n u m s)$ ，因此，我们先将数组 $n u m s$ 从小到大排序。

那么，我们可以在区间： $[0, max (n u m s) - min (n u m s)]$ 通过二分查找，找到第 $k$ 小的数对。

算法步骤：

先将数组 $n u m s$ 从小到大排序；
维护两个指针 $l e f t$ 、 $r i g h t$ ，在区间： $[0, n u m s [- 1] - n u m s [0]]$ ，进行二分查找；
计算当前数对距离的折半值 $m i d$ ：

$m i d = (l e f t + r i g h t) / 2$
对于给定的数对距离 $m i d$ ，我们需要计算：所有距离小于 $m i d$ 的数对个数 $c o u n t$ ，这里也可以使用二分查找：
- 枚举数组 $n u m s$ 中所有元素，并以它作为数对 $(n u m s [i], n u m s [j])$ 的右端点 $n u m s [j]$ ；
- 再对区间 $n u m s [0], \dots, n u m s [j]$ ，进行二分查找，找到所有大于等于 $n u m s [j] - m i d$ 的最小下标 $i$ ；
  
  这样，在区间 $[i, j]$ 内的所有数对 $(n u m s [i], n u m s [j])$ ，一定满足： $n u m s [j] - n u m s [i] < k$ 。
- 累加区间的数对个数 $j - i$ 。
对于当前的距离 $m i d$ ：
- 如果 $c o u n t$ 大于等于 $k$ ，说明当前距离值过大，则右指针 $r i g h t$ 减 $1$ ；
- 如果 $c o u n t$ 小于 $k$ ，说明当前距离值过小，则左指针 $l e f t$ 加 $1$ ；

代码实现

 import heapq
 
class Solution:
    def smallestDistancePair(self, nums: List[int], k: int) -> int:
        nums.sort()
        n = len(nums)
        left, right = 0, nums[n - 1] - nums[0]
        while left <= right:
            mid = left + (right - left) // 2
            if self.check(nums, k, mid):
                right = mid - 1
            else:
                left = mid + 1
        return left
 
    def check(self, nums: List[int], k: int, mid: int) -> bool:
        count = 0
        for j in range(len(nums)):
            count += j - self.binary_search(nums, j, nums[j] - mid)
        return count >= k
 
    def binary_search(self, nums: List[int], end: int, target: int) -> int:
        left, right = 0, end
        while left < right:
            mid = left + (right - left) // 2
            if nums[mid] < target:
                left = mid + 1
            else:
                right = mid
        return left

应用6：Leetcode 540. 有序数组中的单一元素

题目

540. 有序数组中的单一元素

给你一个仅由整数组成的有序数组，其中每个元素都会出现两次，唯有一个数只会出现一次。
请你找出并返回只出现一次的那个数。
你设计的解决方案必须满足 $O (\log_{2} n)$ 时间复杂度和 $O (1)$ 空间复杂度。

示例 1:

输入: nums = [1,1,2,3,3,4,4,8,8]
输出: 2

分析

假设只出现出现一次的元素是 $n u m s [x]$ ，而其余元素都出现了两次，因此数组的长度一定是奇数，并且由于数组是有序的，那么，相同的元素一定是相邻的。

容易发现如下性质：

对于元素 $n u m s [x]$ 左侧的元素，如果前后两个元素相等，即 $n u m s [i] = n u m s [i + 1]$ ，那么，序号 $i$ 一定是偶数；
对于元素 $n u m s [x]$ 右侧的元素，如果前后两个元素相等，即 $n u m s [i] = n u m s [i + 1]$ ，那么，序号 $i$ 一定是奇数。

可以看出，元素 $n u m s [x]$ 是两个子数组的分界，满足二段性。

因此，我们可以在数组 $n u m s$ 上使用二分查找，每次取左右边界的平均值 $m i d$ ，根据 $m i d$ 的奇偶性判断：

如果 $m i d$ 是偶数，则比较 $n u m s [m i d]$ 与 $n u m s [m i d + 1]$ 是否相等
- 如果 $n u m s [m i d] = n u m s [m i d + 1]$ ，说明 $m i d < x$ ，需要移动左边界；
- 如果 $n u m s [m i d] \neq n u m s [m i d + 1]$ ，说明 $m i d \geq x$ ，需要移动右边界。
如果 $m i d$ 是奇数，则比较 $n u m s [m i d - 1]$ 与 $n u m s [m i d]$ 是否相等
- 如果 $n u m s [m i d] = n u m s [m i d - 1]$ ，说明 $m i d < x$ ，需要移动左边界；
- 如果 $n u m s [m i d] \neq n u m s [m i d - 1]$ ，说明 $m i d \geq x$ ，需要移动右边界。
重复上述过程，直到找到元素 $n u m s [x]$ 。

这里，可以利用按位异或的性质，得到 $m i d$ 与其相邻的元素，如下：

如果 $m i d$ 是偶数，那么，有 $m i d + 1 = m i d \oplus 1$ ；
如果 $m i d$ 是奇数，那么，有 $m i d - 1 = m i d \oplus 1$ 。

因此，在二分查找过程中，不需要判断 $m i d$ 的奇偶性，只需要比较 $n u m s [m i d]$ 和 $n u m s [m i d \oplus 1]$ 两个元素即可。

以如下例子，来说明查找过程：

第 1 次查找，查找区间： $[0 ， 8]$ ， $m i d = 4$ , $m i d \oplus 1 = 5$ ，移动左指针： $l e f t = 5$ ；
第 2 次查找，查找区间： $[5 ， 8]$ ， $m i d = 6$ , $m i d \oplus 1 = 7$ ，移动右指针： $r i g h t = 6$ ；
第 3 次查找，查找区间： $[5 ， 6]$ ， $m i d = 5$ , $m i d \oplus 1 = 4$ ，移动左指针： $l e f t = 6$ ，找到只出现一次的元素 $4$ 。

代码实现

 from typing import List
 
 
class Solution:
    def singleNonDuplicate(self, nums: List[int]) -> int:
        low, high = 0, len(nums) - 1
        while low < high:
            mid = (low + high) // 2
            if nums[mid] == nums[mid ^ 1]:
                low = mid + 1
            else:
                high = mid
        return nums[low]

扩展

如果数组是无序的，就可以将所有元素进行按位异或即可找到只出现一次的元素。

本文作者：LARRY1024

本文链接：https://www.cnblogs.com/larry1024/p/17460083.html

posted @ 2023-06-06 15:11 LARRY1024 阅读(19) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 二分搜索应用 II

· 并归排序的应用 I

· Leetcode---5.二分搜索篇

· 有序数组中的单一元素

· 图解 LeetCode 算法汇总——二分查找

公告

昵称：LARRY1024 园龄：11年9个月粉丝：16 关注：3

昵称： LARRY1024
园龄： 11年9个月
粉丝： 16
关注： 3

+加关注

2025年3月

日

一

二

三

四

五

六

	class Solution:
	def search(self, nums: List[int], target: int) -> int:
	if not nums:
	return -1

	left, right = 0, len(nums) - 1
	while left <= right:
	mid = left + (right - left) // 2

	if nums[mid] == target:
	return mid

	if nums[0] <= nums[mid]:
	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

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

	if target >= nums[0]:
	if nums[mid] > target or nums[mid] < nums[0]:
	right = mid - 1
	else:
	left = mid + 1
	else:
	if nums[mid] < target or nums[mid] >= nums[0]:
	left = mid + 1
	else:
	right = mid - 1
	return -1

	class Solution:
	def kthSmallest(self, matrix: List[List[int]], k: int) -> int:
	n = len(matrix)
	left, right = matrix[0][0], matrix[-1][-1]
	while left < right:
	mid = (left + right) // 2
	if self.check(mid, matrix, k):
	right = mid
	else:
	left = mid + 1
	return left

	@classmethod
	def check(cls, mid, matrix, k):
	n = len(matrix)
	# 左下角的坐标
	i, j = n - 1, 0
	num = 0
	# 坐标在矩阵内部可以移动的路线，根据移动的路线，计算左侧元素数量
	while i >= 0 and j < n:
	# 如果当前元素小于mid, 指针向右移动
	if matrix[i][j] <= mid:
	num += i + 1
	j += 1
	# 如果当前元素大于mid，指针向上移动
	else:
	i -= 1
	# 左侧元素的个数大于k，则移动right指针，反之，移动left
	return num >= k

	class Solution:
	def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
	from typing import List


	class Solution:
	def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
	m, n = len(nums1), len(nums2)
	pair_sum = self.findKSmallest(nums1, nums2, k)

	result = []
	# 找数对和小于 pair_sum 的数对
	i = n - 1
	for _num in nums1:
	while i >= 0 and _num + nums2[i] >= pair_sum:
	i -= 1
	# 因为原数组是升序排列的，所以先顺序记录结果，保证小的结果在前面
	for j in range(i + 1):
	result.append([_num, nums2[j]])

	# 找数对和等于 pair_sum 的数对
	i = n - 1
	for _num in nums1:
	while i >= 0 and _num + nums2[i] > pair_sum:
	i -= 1
	# 只寻找数对和等于pair_sum的组合，所以倒序记录
	for j in range(i, -1, -1):
	if _num + nums2[j] == pair_sum:
	result.append([_num, nums2[j]])
	if len(result) == k:
	return result

	return result

	def findKSmallest(self, nums1: List[int], nums2: List[int], k: int):
	""" 通过二分查找第 k 小的数对和 """
	m, n = len(nums1), len(nums2)
	# 查找区间
	left, right = nums1[0] + nums2[0], nums1[m - 1] + nums2[n - 1]
	while left < right:
	mid = (left + right) // 2
	if self._check(mid, nums1, nums2, k):
	left = mid + 1
	else:
	right = mid
	return left

	def _check(self, mid: int, nums1: List[int], nums2: List[int], k: int):
	m, n = len(nums1), len(nums2)
	count = 0
	# 使用两个指针i, j，使i顺序遍历nums1，使j倒序遍历nums2
	i, j = 0, n - 1
	while i < m and j >= 0:
	# 记录数对和小于mid的个数
	if nums1[i] + nums2[j] <= mid:
	count += j + 1
	i += 1
	else:
	j -= 1
	return count < k

	import heapq
	from typing import List


	class Solution:
	def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
	m, n = len(nums1), len(nums2)
	results = []
	pq = [(nums1[i] + nums2[0], i, 0) for i in range(min(k, m))]
	while pq and len(results) < k:
	_, i, j = heapq.heappop(pq)
	results.append([nums1[i], nums2[j]])
	if j + 1 < n:
	heapq.heappush(pq, (nums1[i] + nums2[j + 1], i, j + 1))
	return results

	class Solution {
	double eps = 1e-8;
	int a, b;
	public int[] kthSmallestPrimeFraction(int[] arr, int k) {
	double left = 0, right = 1;
	while (right - left > eps) {
	double mid = (left + right) / 2;
	if (check(arr, mid) >= k) {
	right = mid;
	}
	else {
	left = mid;
	}
	}

	return new int[]{a, b};
	}

	int check(int[] array, double x){
	int count = 0;
	int i = 0;
	for (int j = 1; j < array.length; j++) {
	while (array[i + 1] * 1.0 / array[j] <= x) {
	i++;
	}

	if (array[i] * 1.0 / array[j] <= x) {
	count += i + 1;
	}
	// 记录分数值恰好等于 x 的元素组合
	if (Math.abs(array[i] * 1.0 / array[j] - x) < eps) {
	a = array[i];
	b = array[j];
	}
	}
	return count;
	}
	}

	from typing import List

	EPS = 1e-8


	class Solution:
	def kthSmallestPrimeFraction(self, arr: List[int], k: int) -> List[int]:
	a, b = 0, 0
	left, right = 0.0, 1.0
	while right - left > EPS:
	mid = left + (right - left) / 2
	result = self._check(arr, mid, k)
	if result[0]:
	right = mid
	a, b = result[1], result[2]
	else:
	left = mid

	return [a, b]

	def _check(self, array: List[int], x: float, k):
	count = 0
	i = 0
	a, b = 0, 0
	for j in range(1, len(array)):
	while array[i + 1] * 1.0 / array[j] <= x:
	i += 1

	if array[i] * 1.0 / array[j] <= x:
	count += i + 1
	# 记录分数值恰好等于 x 的元素组合
	if abs(array[i] * 1.0 / array[j] - x) < EPS:
	a = array[i]
	b = array[j]
	return count >= k, a, b

	import heapq
	from typing import List


	class Node(object):
	def __init__(self, index_x: int, index_y: int, x: int, y: int):
	""" x/y """
	self.index_x = index_x
	self.index_y = index_y
	self.x = x
	self.y = y

	def __lt__(self, other):
	return self.x * other.y < self.y * other.x


	class Solution:
	def kthSmallestPrimeFraction(self, arr: List[int], k: int) -> List[int]:
	n = len(arr)
	pq = [Node(0, j, arr[0], arr[j]) for j in range(n)]
	heapq.heapify(pq)

	for _ in range(k - 1):
	node = heapq.heappop(pq)
	if node.index_x + 1 < n:
	next_node = Node(node.index_x + 1, node.index_y, arr[node.index_x + 1], node.y)
	heapq.heappush(pq, next_node)
	node = pq[0]
	return [node.x, node.y]

	import heapq

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

	def check(self, nums: List[int], k: int, mid: int) -> bool:
	count = 0
	for j in range(len(nums)):
	count += j - self.binary_search(nums, j, nums[j] - mid)
	return count >= k

	def binary_search(self, nums: List[int], end: int, target: int) -> int:
	left, right = 0, end
	while left < right:
	mid = left + (right - left) // 2
	if nums[mid] < target:
	left = mid + 1
	else:
	right = mid
	return left

	from typing import List


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

LARRY1024

二分搜索的应用

简介

应用

应用1：Leetcode 33. 搜索旋转排序数组

题目

分析

方法一

算法步骤

方法二

算法步骤

代码实现

方法一

方法二

应用2：Leetcode 81. 搜索旋转排序数组 II

题目

分析

代码实现

应用3：Leetcode 378. 有序矩阵中第 K 小的元素

题目

分析

方法一：二分查找

方法二：归并排序

代码实现

方法一

方法二

应用4：Leetcode 373. 查找和最小的 K 对数字

题目

分析

方法一：二分查找

方法二：多路并归

代码实现

方法一

方法二

应用4：Leetcode 786. 第 K 个最小的素数分数

题目

分析

方法一：二分查找

方法二：多路并归

代码实现

方法一

方法二

应用5：Leetcode 719. 找出第 K 小的数对距离

题目

分析

代码实现

应用6：Leetcode 540. 有序数组中的单一元素

题目

分析

代码实现

扩展

公告

搜索

常用链接

最新随笔

我的标签

积分与排名

合集 (8)

随笔分类 (155)

随笔档案 (139)

阅读排行榜

评论排行榜

推荐排行榜

最新评论