LC T668笔记 & 有关二分查找、第K小数、BFPRT算法

【以下内容仅为本人在做题学习中的所感所想，本人水平有限目前尚处学习阶段，如有错误及不妥之处还请各位大佬指正，请谅解，谢谢！】

 

！！！观前提醒！！！

【本文篇幅较大，如有兴趣建议分段阅读】

 

有关二分查找

作用：在有序集合中快速查找目标值

适用性：

　　1. 只能查找有序的数据集

顺序存储的数据结果就是数组了，也就是二分查找只能从数组中查找，而不能查找链式存储的数据集，比如查找链表中的数，就不能用二分查找。

　　2. 针对的是静态有序数据集

二分查找适合那种不经常变动的数据集合。如果经常插入、删除的数据集，每次插入和删除都要保证集合数据的有序，维护动态数据有序的成本很高。所以二分查找适合从有序的不经常变动的数据集合中查找。适合数据集合已经排好序，但是需要经常查找的场景。

　　3. 不适合数据量太大或者太小的场景

因为二分查找需要依赖数组这种数据结构，而数组要求连续的内存空间，其需要把所有数据全部读入内存中，因此数据量太大的，对内存要求比较高。如果数据量只有几十个，那么不论是使用二分查找还是顺序遍历，查找效率都差不多。

 

有关二分查找的边界问题

“思路很简单，细节是魔鬼”

二分的几个常用情景：寻找一个数、寻找左侧边界、寻找右侧边界

以下是二分查找的基本框架：

public int BinarySearch(int[] nums, int target) {
    int left = 0, right = ...; 
    while(...) {
        int mid = left + ((right - left) >> 1);
        if (nums[mid] == target) {
            ...
        } else if (nums[mid] < target) {
            left = ...
        } else if (nums[mid] > target) {
            right = ...
        }
    }
    return ...;
}

分析二分查找的一个技巧是：不要出现 else，而是把所有情况用 else if 写清楚，这样可以清楚地展现所有细节。

（一）  寻找一个数

public int BinarySearch(int[] nums, int target) {
    int left = 0; 
    int right = nums.length - 1; //【1】

    while(left <= right) { //【2】
        int mid = left + ((right - left) >> 1);
        if(nums[mid] == target)
            return mid; 
        else if (nums[mid] < target)
            left = mid + 1;  //【3】
        else if (nums[mid] > target)
            right = mid - 1;  //【4】
    }
    return -1;
}

　　1. while中的循环条件

循环条件由搜索区间的结构确定，当找到目标值后，返回即可；

若没找到则需考虑终止情况。此处的搜索区间的结构是两端闭区间。当left == right时，表示区间[left, right]，此时区间内仍有一个数值未被搜索，若此时结束循环，可能错过对目标值的匹配，因此需要继续查找，则终止条件应当是left > right时，此时搜索区间为空。所以此处while中应当为“<=”。

如果要使用小于号，则在结尾加一句判断即可。

return nums[left] == target ? left : -1;

　　2.  left与right的加加减减

边界的加减也由搜索区间的结构确定。在[left, right]中mid被检测后，需要据mid将其划分为两个区间，若mid位置上的值不等于target，则不用再考虑mid。因为边界均可取到，所以搜索区间因改为[left, mid – 1]或[mid + 1, right]

　　3.  缺点

当数据中重复出现目标元素，则返回的是在重复序列中中间位置的索引，并不能得到其左侧或右侧边界。如{1, 2, 2, 2, 3, 5}，target = 2，此时返回索引为2，但其边界为[1, 3]

（二）  寻找左侧边界

public int LeftBound(int[] nums, int target) {
    if (nums.length == 0) return -1;
    int left = 0;
    int right = nums.length; //【1】
    
    while (left < right) { //【2】
        int mid = left + ((left + right) >> 1);
        if (nums[mid] == target) {
            right = mid; //【3】
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid; //【4】
        }
    }
    return left;
}

　　1.  while中的循环条件

同理，此处的搜索区间为左闭右开型，当left == right时，表示区间[left, right)，此时的区间已经为空，故可以终止。

注：这里解释一下为何上面用两端闭区间，而这里用左开后闭区间。因为这样的写法比较普遍，不这么写也可以，后文将会展示三种写法(两端闭，左开右闭，左闭右开)。

　　2.  left与right的加减

因为此处是左闭右开区间，在[left， right)中mid被检测后，需要据mid将其划分为两个区间，[left, mid)和[mid + 1, right)。为了保证区间结构不变，所以right应变为mid，left应变为mid + 1

　　3.  有关结尾的返回值

返回值表示目标值在序列中的左侧边界，等价于小于目标值的元素个数。分析可知left的取值范围是[0, nums.Length]，所以当left == nums.Length时，说明没有一个元素小于target，即target在该序列中不存在，返回-1即可。（当然，最终的返回值也可以是right，因为终止条件是left == right）

if (left == nums.length) return -1;
return nums[left] == target ? left : -1;

　　4.  该算法的核心，即为何可以查找左侧边界

if (nums[mid] == target) 
    right = mid;

当nums[mid] == target时，因为数据有序，说明mid左侧可能存在target，所以应缩小上界，不断向左收缩。

　　5.  统一格式，将while循环加入等号

据原理，只需将right初值设为nums.Length – 1；right的变化改为mid – 1即可。

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

（三）  寻找右边界

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

　　1.  left与right的加减

因为此处是左闭右开区间，在[left， right)中mid被检测后，需要据mid将其划分为两个区间，[left, mid)和[mid + 1, right) 。为了保证区间结构不变，所以right应变为mid，left应变为mid + 1

　　2.  有关最后返回值

因为对left的更新为mid + 1，结束时会产生以下结果：

 

[注：上图来源于搜索引擎查找结果】

所以需返回left – 1（也可返回right - 1）。

同理，当left == 0时，说明没有一个元素大于target，即target在该序列中不存在，返回-1即可。

if (left == 0) return -1;
return nums[left-1] == target ? (left-1) : -1;

　　3.  统一格式

public int RightBound(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + ((right - left) >> 1);
        if (nums[mid] == target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else if (nums[mid] < target) {
            left = mid + 1;
        }
    }
    if (right < 0 || nums[right] != target)
        return -1;
    return right;
}

 

小结

1. 写二分查找时，尽量不要出现 else，将所有情况列出来便于分析。

2. 注意搜索区间形式和 while 的终止条件，若存在漏掉的元素，最后特判。

3. 如需定义左闭右开的搜索区间，搜索左右边界，只要在 nums[mid] == target 时做修改即可，搜索右侧时需要减一。

4. 如果将搜索区间全都统一成两端闭，只要修改 nums[mid] == target 条件处的代码和返回的逻辑即可。

 

从一维二分谈起

二分法，用于在集合中查找某些符合要求的元素，可以将时间复杂度降低至对数级。使用二分法的前提是查找序列的有序性，主要思想是从序列中间位置开始，根据当前的中间值与目标值的大小关系，修改区间端点，确定目标值所在区间。

• 题一：搜索旋转排序数组 33. 搜索旋转排序数组 - 力扣（LeetCode）

题意：在半有序的结合中查找目标元素的索引值

思想：选定中点，比较中点值来更改区间，但需要先判断当前所查找的区间是否为有序区间，否则不能使用二分法

//C# Version

public class Solution {
    public int Search(int[] nums, int target) {
        int n = nums.Length;
        if(n == 0) return -1;
        if(n == 1) return nums[0] == target ? 0 : -1;
        
        int left = 0, right = n - 1;
        while(left <= right) {
            int mid = left + ((right - left) >> 1);
            if(target == nums[mid]) return mid;
            if(nums[0] <= nums[mid]) {
                if(nums[0] <= target && target < nums[mid]) right = mid - 1;
                else left = mid + 1;
            }
            else if(nums[0] > nums[mid]){
                if(nums[mid] < target && target <= nums[n - 1]) left = mid + 1;
                else right = mid - 1;
            }
        }
        return -1;
    }
}

 

//C++ Version

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int n = (int)nums.size();
        if(n == 0) return -1;
        if(n == 1) return nums[0] == target ? 0 : -1;

        int left = 0, right = n - 1;
        while(left <= right) {
            int mid = left + ((right - left) >> 1);
            if(target == nums[mid]) return mid;
            if(nums[0] <= nums[mid]) {
                if(nums[0] <= target && target < nums[mid]) right = mid - 1;
                else left = mid + 1;
            }
            else if(nums[0] > nums[mid]){
                if(nums[mid] < target && target <= nums[n - 1]) left = mid + 1;
                else right = mid - 1;
            }
        }
        return -1;
    }
};

 

• 题二：长度最小的子数组 209. 长度最小的子数组 - 力扣（LeetCode）

题意：找出数组中满足其和大于等于目标值的长度最小的连续子序列

思想：要判断连续区间内的和，就先求出原数组的前缀和，因为题保证了数组中每个元素都为正，所以前缀和一定是递增的，保证了二分的正确性。

得到前缀和之后，对于每个开始下标 i，可通过二分查找得到大于或等于i的最小下标 bound，使得 sum[bound] - sum [i−1] ≥ target，并更新子数组的最小长度，此时子数组的长度是bound - i + 1。

 【注：此解法非最优解】

//C# Version

public class Solution {
    public int MinSubArrayLen(int target, int[] nums) {
        int n = nums.Length;
        if (n == 0) return 0;
        int ans = int.MaxValue;
        int[] sums = new int[n + 1];
        for (int i = 1; i <= n; ++i) 
            sums[i] = sums[i - 1] + nums[i - 1];
        for (int i = 1; i <= n; ++i) {
            int s = target + sums[i - 1];
            int bound = LowerBound(sums, i, n - 1, s);
            if (bound != -1)
                ans = Math.Min(ans, bound - i + 1);
        }
        return ans == int.MaxValue ? 0 : ans;
    }
    private int LowerBound(int[] nums, int left, int right, int s) {
        while (left <= right) {
            int mid = left + ((right - left) >> 1);
            if (nums[mid] < s) left = mid + 1;
            else right = mid - 1;
        } 
        return (nums[left] >= s) ? left : -1;
    }
}

 

//C++ Version

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n = nums.size();
        if (n == 0) return 0;
        int ans = INT_MAX;
        vector<int> sums(n + 1, 0); 
        for (int i = 1; i <= n; i++)
            sums[i] = sums[i - 1] + nums[i - 1];
        for (int i = 1; i <= n; i++) {
            int target = s + sums[i - 1];
            auto bound = lower_bound(sums.begin(), sums.end(), target);
            if (bound != sums.end())
                ans = min(ans, static_cast<int>((bound - sums.begin()) - (i - 1)));
        }
        return ans == INT_MAX ? 0 : ans;
    }
};

 

• 题三：寻找峰值 162. 寻找峰值 - 力扣（LeetCode）

题意：找到数组中某个峰值元素的索引（且nums[-1]与nums[len] = 负无穷）

思想：首先思考如何判断峰值所在区间。

假设mid < mid + 1

• 对于mid – 1，无论是mid – 1 > mid还是mid – 1 > mid均不能得到mid是峰值；
• 对于mid + 2，有两种情况：若mid + 2 < mid + 1则峰值为mid + 1；若mid + 2 > mid + 1，继续后推，由于边界后的值为-∞，那么一定可以得到最后一个值为峰值。

综上：峰值一定在较大的一部分。

//C# Version

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

 

//C++ Version

int findPeakElement(vector<int>& nums) {
    int left = 0, right = nums.size() - 1;
    for (; left < right; ) {
        int mid = left + (right - left) / 2;
        if (nums[mid] > nums[mid + 1]) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}

 

小结

一维二分思想和操作较为简单，具体步骤为：

　　1. 确定并构建查找对象。即是查找元素，还是查找和、差等，构建出用于查找的序列，如：前缀和。

　　2.  判断二分后目标值可能的所在区间。一般是通过中值和目标值的比较更改区间，特殊地（如峰值寻找）需要运用一定数学知识进行判断。

 

有关二维二分

二维本质上可以看作是一维的叠加，某些简单的情况下，可以一维一维的查找。也可以从定义出发，从中点开始进行区间更改。当然，二维二分也有一些常见的变式，如从一个端点、对角线两个端点出发等。

• 题一：搜索二维矩阵 74. 搜索二维矩阵 - 力扣（LeetCode）

题意：在二维矩阵中查找某个值是否存在。

思想：可以将二维数组划分为一维数组，一行一行或一列一列进行判断。可以对矩阵的第一列的元素二分查找，找到最后一个不大于目标值的元素，然后在该元素所在行，进行二分查找目标值是否存在。

 1 //C# Version
 2 
 3 class Solution {
 4     public bool SearchMatrix(int[][] matrix, int target) {
 5         int rowIndex = BinarySearchFirstColumn(matrix, target);
 6         if (rowIndex < 0) return false;
 7         return BinarySearchRow(matrix[rowIndex], target);
 8     }
 9 
10     private int BinarySearchFirstColumn(int[][] matrix, int target) {
11         int low = -1, high = matrix.Length - 1;
12         while (low < high) {
13             int mid = (high - low + 1) / 2 + low;
14             if (matrix[mid][0] <= target) low = mid;
15             else high = mid - 1;
16         }
17         return low;
18     }
19 
20     private bool BinarySearchRow(int[] row, int target) {
21         int low = 0, high = row.Length - 1;
22         while (low <= high) {
23             int mid = (high - low) / 2 + low;
24             if (row[mid] == target) return true;
25             else if (row[mid] > target) high = mid - 1;
26             else low = mid + 1;
27         }
28         return false;
29     }
30 }

 

也可以从定义出发，从中间点开始进行判断。

 1 //C# Version
 2 
 3 public class Solution {
 4     public bool SearchMatrix(int[][] matrix, int target) {
 5         int m = matrix.Length, n = matrix[0].Length;
 6         int low = 0, high = m * n - 1;
 7         while (low <= high) {
 8             int mid = low + ((high - low) >> 1);
 9             int x = matrix[mid / n][mid % n];
10             if (x < target) low = mid + 1;
11             else if (x > target) high = mid - 1;
12             else return true;
13         }
14         return false;
15     }
16 }

 

注意到每行的第一个整数大于前一行的最后一个整数。因此，把每一行拼接到前一行可以得到一个递增序列，所以可以从右上角开始进行判断。

 1 //C# Version
 2 
 3 public class Solution {
 4     public bool SearchMatrix(int[][] matrix, int target) {
 5         int n = matrix.Length;
 6         if(n == 0) return false;
 7         int row = 0, col = matrix[0].Length - 1;
 8         while(row < n && col >= 0)
 9         {
10             if(matrix[row][col] < target) row++;
11             else if(matrix[row][col] >target) col--;
12             else return true;
13         }
14         return false;
15     }
16 }

 

 1 //C++ Version
 2 
 3 class Solution {
 4 public:
 5     bool searchMatrix(vector<vector<int>>& matrix, int target) {
 6         int row = matrix.size(), col = matrix[0].size();
 7         for(int i = 0, j = col-1; i < row && j >= 0;) {
 8             if(matrix[i][j] == target) 
 9                 return true;
10             else if(matrix[i][j] > target) 
11                 j--;
12             else if(matrix[i][j] < target)
13                 i++;
14         }
15         return false;
16     }
17 };

 

• 题二：有序矩阵中的第K小的元素 378. 有序矩阵中第 K 小的元素 - 力扣（LeetCode）

题意：在矩阵中找到第K小数

思想：可以从定义出发，从中间点开始进行判断。关键是统计对于当前数mid，有多少个比它小的数。

若每行的第一个整数大于前一行的最后一个整数，则cnt = i * n + j。但本题不满足该条件，则需要寻找一个参照值，通过循环，统计小于等于当前值的元素数。观察四个边角，左上角的元素最小，右下角的元素最大，而左下角和右上角的元素大小与mid相比是未定的，不妨取二者其一作为参照值。

在此，取左下角的值为参照值。

 1 //C# Version
 2 
 3 public class Solution {
 4     public int KthSmallest(int[][] matrix, int k) {
 5         int n = matrix.Length;
 6         int left = matrix[0][0], right = matrix[n - 1][n - 1];
 7         while(left < right) {
 8             int mid = left + ((right - left) >> 1);
 9             if(Check(matrix, mid, k, n)) right = mid;
10             else left = mid + 1;
11         }
12         return left;
13     }
14     private bool Check(int[][] matrix, int mid, int k, int n) {
15         int cnt = 0;
16         int i = n - 1, j = 0;
17         while(i >= 0 && j < n) {
18             if(matrix[i][j] > mid) i--;
19             else {
20                 cnt += i + 1;
21                 j++;
22             }
23         }
24         return cnt >= k;
25     }
26 }

 

• 题三 乘法表中第K小数 668. 乘法表中第k小的数 - 力扣（LeetCode）

本题与上题类似，只是在计数上有变化。

 1 /C# Version
 2 
 3 public class Solution {
 4     public int FindKthNumber(int m, int n, int k) {
 5         int left = 1, right = m * n;
 6         while(left < right) {
 7             int mid = left + ((right - left) >> 1);
 8             if(CheckCnt(mid, k, m, n)) right = mid;
 9             else left = mid + 1;
10         }
11         return left;
12     }
13     private bool CheckCnt(int mid, int k, int m, int n) {
14         int cnt = 0;
15         for(int i = 1; i <= m; i++) cnt += Math.Min(mid / i, n);
16         return cnt >= k;
17     }
18 }

 

小结

二维二分通常从边角出发，通常以边角值为参照值，进行区间的更新。其本质依旧是比大小，改区间。

 

有关第K小数

在此介绍一种算法：中位数的中位数算（BFPRT），该算法主要解决TOP-K问题。

有一个经典的问题，“从长度为N的无序数组中找出前k大的数”。TOP-K问题的最简单解法为快速排序后取第K大的数，但快速排序可能会达到最坏情况时间复杂度O(n²)，且会对无用的数据进行排序操作（归并除外）。而该算法的主要优化是，修改快速排序选择主元的方法，优化最坏时间复杂度。

对于快速排序，一般选择中间位置的元素作为参照值，将小的数移到参照值左边，大的数移到右边，此时对于中间位置的该值，即为序列中第n/2小的数。

那么，是否可以用类似的方法，通过一次O(n)的操作找出第k小数呢？

该算法通过“随机选择”实现了这个操作，其思想与快排类似，仅仅改变了对参照值的选取。

具体流程：

　　1.将n个元素划为 n/5 组，每组5个，至多只有一组由 n%5 个元素组成。

　　2.寻找每一个组的中位数（可以用插排）。

　　3.对步骤2选出的 n/5 个中位数，重复步骤1和步骤2，递归下去，直到剩下一个数字。

　　4.最终剩下的数字近似为序列的中位数pivot，把小于等于它的数放左边，大于的数放右边。

　　5.判断pivot的位置与k的大小，如果pivot > k，则在[0, pivot – 1]内寻找第k小数；反之在[pivot + 1, n - 1]内寻找 k – pivot 小的数。

注意下面两种分治的思想：

　　1.分治法O(nlogn)：大问题分解为小问题，小问题都要递归各个分支，例如：快速排序。

　　2.减治法O(n)：大问题分解为小问题，小问题只要递归一个分支，例如：二分查找，随机选择。

#include <bits/stdc++.h>
using namespace std;

int InsertSort(int array[], int left, int right);
int GetPivotIndex(int array[], int left, int right);
int Partition(int array[], int left, int right, int pivot_index);
int BFPRT(int array[], int left, int right, int k);

///划分
int Partition(int arr[], int left, int right, int pivot_index) {
    swap(arr[pivot_index], arr[right]); // 把主元放置于末尾

    int partition_index = left; // 跟踪划分的分界线
    for (int i = left; i < right; i++)
        if (arr[i] < arr[right])
            swap(arr[partition_index++], arr[i]); // 比pivot小的都放在左侧

    swap(arr[partition_index], arr[right]); // 最后把pivot换回来
    return partition_index;
}

///返回第 k 小数的下标
int BFPRT(int arr[], int left, int right, int k) {
    int pivot_index = GetPivotIndex(arr, left, right); // 得到中位数的中位数下标
    int partition_index = Partition(arr, left, right, pivot_index); // 进行划分，返回划分边界
    int num = partition_index - left + 1;

    if (num == k)
        return partition_index;
    else if (num > k)
        return BFPRT(arr, left, partition_index - 1, k);
    else
        return BFPRT(arr, partition_index + 1, right, k - num);
}

///返回 [left, right]的中位数。
int Insertion(int arr[], int left, int right) {
    int temp, j;
    for (int i = left + 1; i <= right; i++) {
        temp = arr[i];
        j = i - 1;
        while (j >= left && arr[j] > temp) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = temp;
    }
    return left + ((right - left) >> 1);
}

///数组每五个元素作为一组，并计算每组的中位数，最后返回这些中位数的中位数下标
///末尾返回语句最后一个参数多加 1 的作用是向上取整，可以始终保持 k 大于 0。
int GetPivotIndex(int arr[], int left, int right) {
    if (right - left < 5)
        return Insertion(arr, left, right);
    int sub_right = left - 1;
    
    // 每五个作为一组，求出中位数，并把这些中位数全部依次移动到数组左边
    for (int i = left; i + 4 <= right; i += 5) {
        int index = Insertion(arr, i, i + 4);
        swap(arr[++sub_right], arr[index]);
    }

    // 利用 BFPRT 得到这些中位数的中位数下标
    return BFPRT(arr, left, sub_right, ((sub_right - left + 1) >> 1) + 1);
}

int main() {
    ios::sync_with_stdio(false);
    int k = 8; // 1 <= k <= array.size
    int nums[20] = { 12, 9, 7, 1, 13, 9, 15, 0, 26, 2, 17, 5, 14, 31, 6, 18, 22, 7, 19, 41 };

    cout << "The Source Data：";
    for (int i = 0; i < 20; i++)
        cout << nums[i] << " ";
    cout << endl;

    // 因为是以 k 为划分，所以还可以求出第 k 小值
    cout << "The Kth smallest number：" << nums[BFPRT(nums, 0, 19, k)] << endl;

    cout << "After Processing：";
    for (int i = 0; i < 20; i++)
        cout << nums[i] << " ";
    cout << endl;
    return 0;
}

TRANSLATE with x

English

Arabic	Hebrew	Polish
Bulgarian	Hindi	Portuguese
Catalan	Hmong Daw	Romanian
Chinese Simplified	Hungarian	Russian
Chinese Traditional	Indonesian	Slovak
Czech	Italian	Slovenian
Danish	Japanese	Spanish
Dutch	Klingon	Swedish
English	Korean	Thai
Estonian	Latvian	Turkish
Finnish	Lithuanian	Ukrainian
French	Malay	Urdu
German	Maltese	Vietnamese
Greek	Norwegian	Welsh
Haitian Creole	Persian

 

TRANSLATE with

COPY THE URL BELOW

Back

EMBED THE SNIPPET BELOW IN YOUR SITE

Enable collaborative features and customize widget: Bing Webmaster Portal

Back