二分查找

最新推荐文章于 2024-10-11 21:16:59 发布
最新推荐文章于 2024-10-11 21:16:59 发布
阅读量612 收藏 1
点赞数
分类专栏： 算法和数据结构 笔试面试

二分查找，最基本的算法之一，也是面试中常被考察的重点，因为基本的算法最能反映出一个人的基础是否扎实。本文对二分查找相关题目做一个总结。

题目列表：

1. 给定一个有序（非降序）数组A，求任意一个i使得A[i]等于target，不存在则返回-1
2. 给定一个有序（非降序）数组A，可含有重复元素，求最小的i使得A[i]等于target，不存在则返回-1
3. 给定一个有序（非降序）数组A，可含有重复元素，求最大的i使得A[i]等于target，不存在则返回-1
4. 给定一个有序（非降序）数组A，可含有重复元素，求最大的i使得A[i]小于target，不存在则返回-1
5. 给定一个有序（非降序）数组A，可含有重复元素，求最小的i使得A[i]大于target，不存在则返回-1
6. 给定一个有序（非降序）数组A，可含有重复元素，求target在数组中出现的次数。
7. 给定一个有序（非降序）数组A，若target在数组中出现，返回位置，若不存在，返回它应该插入的位置。
8. 给定一个有序（非降序）数组A，可含有重复元素，求绝对值最小的元素的位置
9. 给定一个有序（非降序）数组A和一个有序（非降序）数组B，可含有重复元素，求两个数组合并结果中的第k(k>=0)个数字。
10. 一个有序（升序）数组，没有重复元素，在某一个位置发生了旋转后，求target在变化后的数组中出现的位置，不存在则返回-1.
11. 一个有序（升序）数组，没有重复元素，在某一个位置发生了旋转后，求最小值所在位置
12. 一个有序（升序）数组，没有重复元素，在某一个位置发生了旋转后，求第k(k > 0)小元素

1. 给定一个有序（非降序）数组A，求任意一个i使得A[i]等于target，不存在则返回-1
这个是最原始的二分查找题目，利用数组的有序特性，拆半查找，使得查找时间复杂度为O(logN)。请参考实现代码与注释。

[cpp]  view plain copy
  1. int search(int A[], int n, int target)  
  2. {  
  3.     int low = 0, high = n-1;  
  4.     while(low <= high)  
  5.     {  
  6.         // 注意：若使用(low+high)/2求中间位置容易溢出  
  7.         int mid = low+((high-low)>>1);   
  8.         if(A[mid] == target)  
  9.             return mid;  
  10.         else if(A[mid] < target)  
  11.             low = mid+1;  
  12.         else // A[mid] > target  
  13.             high = mid-1;  
  14.     }  
  15.     return -1;  
  16. }  
2. 给定一个有序（非降序）数组A，可含有重复元素，求最小的i使得A[i]等于target，不存在则返回-1
此题也就是求target在数组中第一次出现的位置。这里可能会有人想先直接用原始的二分查找，如果不存在直接返回-1，如果存在，然后再顺序找到这个等于target值区间的最左位置，这样的话，最坏情况下的复杂度就是O（n）了，没有完全发挥出二分查找的优势。这里的解法具体过程请参考实现代码与注释。

[cpp]  view plain copy
  1. int searchFirstPos(int A[], int n, int target)  
  2. {  
  3.     if(n <= 0) return -1;  
  4.     int low = 0, high = n-1;  
  5.     while(low < high)  
  6.     {  
  7.         int mid = low+((high-low)>>1);  
  8.         if(A[mid] < target)  
  9.             low = mid+1;  
  10.         else // A[mid] >= target  
  11.             high = mid;  
  12.     }  
  13.     /*  
  14.     循环过程中，当low大于0时，A[low-1]是小于target的，因为A[mid] < target时， 
  15.     low=mid+1；当high小于n-1时，A[high]是大于等于target的，因为A[mid] >= target时， 
  16.     high = mid；循环结束时，low 等于 high，所以，如果A[low](A[high])等于target， 
  17.     那么low(high)就是target出现的最小位置，否则target在数组中不存在。 
  18.     */  
  19.     if(A[low] != target)  
  20.         return -1;  
  21.     else  
  22.         return low;  
  23. }  

3. 给定一个有序（非降序）数组A，可含有重复元素，求最大的i使得A[i]等于target，不存在则返回-1

此题也就是求target在数组中最后一次出现的位置。与上一题基本一样，但是有个地方要注意，具体请参考实现代码与注释。

[cpp]  view plain copy
  1. int searchLastPos(int A[], int n, int target)  
  2. {     
  3.     if(n <= 0) return -1;  
  4.     int low = 0, high = n-1;  
  5.     while(low < high)  
  6.     {  
  7.         /* 
  8.         这里中间位置的计算就不能用low+((high-low)>>1)了，因为当low+1等于high 
  9.         且A[low] <= target时，会死循环；所以这里要使用low+((high-low+1)>>1)， 
  10.         这样能够保证循环会正常结束。 
  11.         */  
  12.         int mid = low+((high-low+1)>>1);  
  13.         if(A[mid] > target)  
  14.             high = mid-1;  
  15.         else // A[mid] <= target  
  16.             low = mid;  
  17.     }  
  18.     /*  
  19.     循环过程中，当high小于n-1时，A[high+1]是大于target的，因为A[mid] > target时， 
  20.     high=mid-1；当low大于0时，A[low]是小于等于target的，因为A[mid] <= target时， 
  21.     low = mid；循环结束时，low 等于 high，所以，如果A[high](A[low])等于target， 
  22.     那么high(low)就是target出现的最大位置，否则target在数组中不存在。 
  23.     */  
  24.     if(A[high] != target)  
  25.         return -1;  
  26.     else  
  27.         return high;  
  28. }  

4. 给定一个有序（非降序）数组A，可含有重复元素，求最大的i使得A[i]小于target，不存在则返回-1。

也就是求小于target的最大元素的位置。请参考实现代码与注释。

[cpp]  view plain copy
  1. int searchLastPosLessThan(int A[], int n, int target)  
  2. {  
  3.     if(n <= 0) return -1;  
  4.     int low = 0, high = n-1;  
  5.     while(low < high)  
  6.     {  
  7.         int mid = low+((high-low+1)>>1); // 注意，不要导致死循环  
  8.         if(A[mid] < target)  
  9.             low = mid;  
  10.         else // A[mid] >= target  
  11.             high = mid-1;  
  12.     }  
  13.     /*  
  14.     循环过程中，当low大于0时，A[low]是小于target的，因为A[mid] < target时， 
  15.     low=mid；当high小于n-1时，A[high+1]是大于等于target的，因为A[mid] >= target时， 
  16.     high = mid-1；循环结束时，low 等于 high，所以，如果A[low](A[high])小于target， 
  17.     那么low(high)就是要找的位置，否则不存在这样的位置（A[0] >= target时）。 
  18.     */  
  19.     return A[low] < target ? low : -1;  
  20. }  
5. 给定一个有序（非降序）数组A，可含有重复元素，求最小的i使得A[i]大于target，不存在则返回-1。
也就是求大于target的最小元素的位置。请参考实现代码与注释。

[cpp]  view plain copy
  1. int searchFirstPosGreaterThan(int A[], int n, int target)  
  2. {  
  3.     if(n <= 0) return -1;  
  4.     int low = 0, high = n-1;  
  5.     while(low < high)  
  6.     {  
  7.         int mid = low+((high-low)>>1);  
  8.         if(A[mid] > target)  
  9.             high = mid;  
  10.         else // A[mid] <= target  
  11.             low = mid+1;  
  12.     }  
  13.     /*  
  14.     循环过程中，当low大于0时，A[low-1]是小于等于target的，因为A[mid] <= target时， 
  15.     low=mid+1；当high小于n-1时，A[high]是大于target的，因为A[mid] > target时， 
  16.     high = mid；循环结束时，low 等于 high，所以，如果A[high](A[low])大于target， 
  17.     那么high(low)就是要找的位置，否则不存在这样的位置（A[n-1] <= target时）。 
  18.     */  
  19.     return A[high] > target ? high : -1;  
  20. }  

6. 给定一个有序（非降序）数组A，可含有重复元素，求target在数组中出现的次数

求出第一次出现位置和最后一次出现位置。由于前面都已实现，这里不多解释。请参考实现代码与注释

[cpp]  view plain copy
  1. int count(int A[], int n, int target)  
  2. {  
  3.     int firstPos = searchFirstPos(A, n, target); // 第一次出现位置  
  4.     if(firstPos == -1)  
  5.         return 0;  
  6.     int lastPos = searchLastPos(A, n, target);  // 最后一次出现位置  
  7.     return lastPos-firstPos+1;  // 出现次数  
  8. }  

此题描述或者改为求目标值在数组中的索引范围。

7. 给定一个有序（非降序）数组A，若target在数组中出现，返回位置，若不存在，返回它应该插入的位置

如    [1,3,5,6], 5 → 2
[1,3,5,6], 2 → 1
[1,3,5,6], 7 → 4
[1,3,5,6], 0 → 0

[cpp]  view plain copy
  1. int searchInsert(int A[], int n, int target) {  
  2.     // 如果比最大值还大，那插入位置就是位置n  
  3.     if(A[n-1] < target)   
  4.         return n;  
  5.     int low = 0, high = n-1;  
  6.     while(low < high)  
  7.     {  
  8.         int mid = low+((high-low)>>1);  
  9.         if(A[mid] >= target)  
  10.             high = mid;  
  11.         else // A[mid] < target  
  12.             low = mid+1;  
  13.     }  
  14.     /*   
  15.     循环过程中，当low大于0时，A[low-1]是小于target的，因为A[mid] < target时，  
  16.     low=mid+1；当high小于n-1时，A[high]是大于等于target的，因为A[mid] >= target时，  
  17.     high = mid；循环结束时，low 等于 high，所以，如果A[low](A[high])等于target，  
  18.     那么low(high)就是target出现的位置，否则low就是target在数组中应该插入的位置。  
  19.     */  
  20.     return high;  
  21. }  

8. 给定一个有序（非降序）数组A，可含有重复元素，求绝对值最小的元素的位置

找第一个大于等于0的位置，然后和前一个元素的绝对值比较，返回绝对值较小的元素的位置。请参考实现代码与注释

[cpp]  view plain copy
  1. int searchMinAbs(int A[], int n)  
  2. {  
  3.     int low = 0, high = n-1;  
  4.     while(low < high)  
  5.     {  
  6.         int mid = low+((high-low)>>1);  
  7.         if(A[mid] < 0)  
  8.             low = mid+1;  
  9.         else // A[mid] >= 0  
  10.             high = mid;  
  11.     }  
  12.     /* 循环结束时，如果low != n-1，A[low] >= 0，如果low>0，A[low-1] < 0 */  
  13.     if(low > 0 && abs(A[low-1]) < abs(A[low]))  
  14.         return low-1;  
  15.     else  
  16.         return low;  
  17. }  

9. 给定一个有序（非降序）数组A和一个有序（非降序）数组B，可含有重复元素，求两个数组合并结果中的第k(k>=0)个数字。

这个题目出现了两个数组，有序的，不管怎样我们就应该首先考虑二分查找是否可行。若使用顺序查找，时间复杂度最低为O(k)，就是类似归并排序中的归并过程。使用用二分查找时间复杂度为O(logM+logN)。二分查找的具体实现过程请参考实现代码与注释。

[cpp]  view plain copy
  1. int findKthIn2SortedArrays(int A[], int m, int B[], int n, int k)  
  2. {  
  3.     if(m <= 0) // 数组A中没有元素，直接在B中找第k个元素  
  4.         return B[k];  
  5.     if(n <= 0) // 数组B中没有元素，直接在A中找第k个元素  
  6.         return A[k];  
  7.     int i = (m-1)>>1; // 数组A的中间位置  
  8.     int j = (n-1)>>1; // 数组B的中间位置  
  9.     if(A[i] <= B[j])  // 数组A的中间元素小于等于数组B的中间元素  
  10.     {  
  11.         /* 
  12.         设x为数组A和数组B中小于B[j]的元素数目，则i+1+j+1小于等于x， 
  13.         因为A[i+1]到A[m-1]中还可能存在小于等于B[j]的元素； 
  14.         如果k小于i+1+j+1，那么要查找的第k个元素肯定小于等于B[j]， 
  15.         因为x大于等于i+1+j+1；既然第k个元素小于等于B[j]，那么只 
  16.         需要在A[0]~A[m-1]和B[0]~B[j]中查找第k个元素即可，递归调用下去。 
  17.         */  
  18.         if(k < i+1+j+1)  
  19.         {  
  20.             if(j > 0)  
  21.                 return findKthIn2SortedArrays(A, m, B, j+1, k);  
  22.             else // j == 0时特殊处理，防止死循环  
  23.             {  
  24.                 if(k == 0)  
  25.                     return min(A[0], B[0]);  
  26.                 if(k == m)  
  27.                     return max(A[m-1], B[0]);  
  28.                 return A[k] < B[0] ? A[k] : max(A[k-1], B[0]);  
  29.             }  
  30.         }  
  31.         /* 
  32.         设y为数组A和数组B中小于于等于A[i]的元素数目，则i+1+j+1大于等于y； 
  33.         如果k大于等于i+1+j+1，那么要查找到第k个元素肯定大于A[i]，因为 
  34.         i+1+j+1大于等于y；既然第k个元素大于A[i]，那么只需要在A[i+1]~A[m-1] 
  35.         和B[0]~B[n-1]中查找第k-i-1个元素，递归调用下去。 
  36.         */  
  37.         else  
  38.             return findKthIn2SortedArrays(A+i+1, m-i-1, B, n, k-i-1);  
  39.     }   
  40.     // 如果数组A的中间元素大于数组B的中间元素，那么交换数组A和B，重新调用即可  
  41.     else  
  42.         return findKthIn2SortedArrays(B, n, A, m, k);  
  43. }  

10. 一个有序（升序）数组，没有重复元素，在某一个位置发生了旋转后，求target在变化后的数组中出现的位置，不存在则返回-1

如 0 1 2 4 5 6 7 可能变成 4 5 6 7 0 1 2

我们先比较中间元素是否是目标值，如果是返回位置。如果不是，我们就应该想办法将搜索区间减少一半。因为存在旋转变化，所以我们要多做一些判断。我们知道因为只有一次旋转变化，所以中间元素两边的子数组肯定有一个是有序的，那么我们可以判断target是不是在这个有序的子数组中，从而决定是搜索这个子数组还是搜索另一个子数组。具体请参考实现代码与注释。

[cpp]  view plain copy
  1. int searchInRotatedArray(int A[], int n, int target)   
  2. {  
  3.     int low = 0, high = n-1;  
  4.     while(low <= high)  
  5.     {  
  6.         int mid = low+((high-low)>>1);  
  7.         if(A[mid] == target)   
  8.             return mid;  
  9.         if(A[mid] >= A[low])   
  10.         {  
  11.             // low ~ mid 是升序的  
  12.             if(target >= A[low] && target < A[mid])  
  13.                 high = mid-1;  
  14.             else  
  15.                 low = mid+1;  
  16.         }  
  17.         else  
  18.         {  
  19.             // mid ~ high 是升序的  
  20.             if(target > A[mid] && target <= A[high])  
  21.                 low = mid+1;  
  22.             else  
  23.                 high = mid-1;  
  24.         }  
  25.     }  
  26.     return -1;  
  27. }  

如果这样的数组中存在重复元素，还能使用二分吗？答案是不能。请看几个例子

[1, 2, 2, 2, 2], [2, 1, 2, 2, 2], [2, 2, 1, 2, 2], [2, 2, 2, 1, 2], [2, 2, 2, 2, 1]这些都是有第一个数组旋转一次变化来的，我们不能通过二分确定是否存在元素1.

11. 一个有序（升序）数组，没有重复元素，在某一个位置发生了旋转后，求最小值所在位置

如果中间元素小于左端元素，则最小值在左半区间内（包含中间元素）；如果中间元素大于右端元素，则最小值在右半区间内（包含中间元素）。请参考实现代码与注释。

[cpp]  view plain copy
  1. int searchMinInRotatedArray(int A[], int n)   
  2. {  
  3.     if(n == 1)  
  4.         return 0;  
  5.     int low = 0, high = n-1;  
  6.     while(low < high-1) // 保证mid != low且mid != high  
  7.     {  
  8.         int mid = low+((high-low)>>1);  
  9.         if(A[mid] < A[low]) // 最小值在low~mid  
  10.             high = mid;  
  11.         else // A[mid] > A[low], // 最小值在mid和high之间  
  12.             low = mid;  
  13.     }  
  14.     return A[low] < A[low+1] ? low : low+1;  
  15. }  
12. 一个有序（升序）数组，没有重复元素，在某一个位置发生了旋转后，求第k(k > 0)小元素的位置
我们可以利用上一题的解答，求出最小值所在位置后，便可以求出第k小元素。请参考实现代码与注释

[cpp]  view plain copy
  1. int searchKthInRotatedArray(int A[], int n, int k)   
  2. {  
  3.     int posMin = searchMinInRotatedArray(A, n);  
  4.     return (posMin+k-1)%n;  
  5. }  
vic__vic
关注
专栏目录
二分查找，你真的掌握了吗？
计算机的艺术
05-21 1万+
版权所有，转载请注明出处，谢谢！ http://blog.csdn.net/walkinginthewind/article/details/8937978 二分查找，最基本的算法之一，也是面试中常被考察的重点，因为基本的算法最能反映出一个人的基础是否扎实。本文对二分查找相关题目做一个总结。 题目列表： 1. 给定一个有序（非降序）数组A，求任意一个i使得A[i]等于target，不存
二分查找的优雅写法 / 在排序数组中二分寻找一个数的出现次数/范围/第一次出现/最后一次出现
ZZXN的博客
04-28 730
目录二分查找的优雅写法0 二分查找的分类1 求第一个大于等于查找值的位置2 求第一个大于查找值的位置3 求最后一个小于(等于)查找值的位置4 求某一个值的出现范围/次数5 示例 二分查找的优雅写法 根据返回值的要求不同，二分查找有以下几种（假定我们在一个整数数组中查找某个value） 0 二分查找的分类 有下面几种形式的要求： 如果存在，返回true，否则返回false。 如果存在，返回第一次...
3. LintCode 二分法经典题目
Asiawyz的博客
12-07 312
3. LintCode 二分法题目 2. LintCode双指针题目（二） 整理自九章。 第一境界 写出不会死循环的二分法 递归与非递归的权衡 第二境界 在排序的数据集上进行二分 找到满足某个条件的第一个位置或者最后一个位置 第三境界 在未排序的数据集上进行二分 保留有解的一半，或者去掉无解的一半 第四境界 在答案集上进行二分 二分答案并验证答案偏大还是偏小 LintCode 457：经典二分查找问题 https://www.lintcode.com/problem/classi
有序数组的二分查找---查找元素第一次和最后一次出现的位置
Baymax_wyl的博客
05-16 4168
package searching; public class BinSearch_first_last { public static void main(String[] args) { // TODO Auto-generated method stub int[] a={3,5,10,10,10,13,13,19,23}; System.out.println(first...
使用二分法--比较有趣的几道题
flamingobaby的博客
10-16 797
1011. 在 D 天内送达包裹的能力 传送带上的包裹必须在 D 天内从一个港口运送到另一个港口。 传送带上的第 i 个包裹的重量为 weights[i]。每一天，我们都会按给出重量的顺序往传送带上装载包裹。我们装载的重量不会超过船的最大运载重量。 返回能在 D 天内将传送带上的所有包裹送达的船的最低运载能力。 示例 1： 输入：weights = [1,2,3,4,5,6,7,8,9,10], D = 5 输出：15 解释： 船舶最低载重 15 就能够在 5 天内送达所有包裹，如下所示： 第 1
二分查找算法PPT课件
04-11
二分查找算法，二分查找算法课件，二分查找算法PPT
二分法题目汇总
qq_41726606的博客
03-06 454
二分题目汇总二分专题题目汇总（91alg-3）其他二分题目汇总 二分专题题目汇总（91alg-3） 题目 知识点 我的题解 其他题解 69. x 的平方根 二分法找右边界 力扣题解 官方题解 278. 第一个错误的版本 二分法找左边界 力扣题解 官方题解 Triple Inversion 二分 + 排序 CSDN题解 官方题解 Minimum-Light-Radius 二分法找左右边界 CSDN题解 – 719. 找出第 k 小的距离对 二分 + 双指针 力扣题解 – 7
二分法相关题目
业精于勤荒于嬉 行成于思毁于随
04-05 166
一般用法： public int binarySearch(int[] nums, int key) { int l = 0, h = nums.length - 1; while (l <= h) { int m = l + (h - l) / 2; // 防止l+h越界 if (nums[m] == key) { r...
二分查找（包括查找元素是第一次和最后出现的位置）
ziggybowie的博客
09-16 511
有序数组中的二分查找 这篇文章用于复习 二分的思想 进入循环，不断的将数组的中间键(mid)和被查找的键比较，若相等则返回mid，若不等则算法会把查找范围缩小一半 确定一个区间，使得目标值一定在区间中 确定一个性质，使得此性质是二段性的，即为将数组分为连续的两段，其中一段满足性质，另一段不满足 且答案是二段性的分界点 整数二分 整数二分分为两大类 while(L<R){ M = (L+...
【二分算法】——8个题目让你找到二分算法的感觉势如破竹
最新发布
酷酷的伟的博客
10-11 1552
这些步骤都是基于二分查找法的变种，核心思想是逐步缩小搜索范围以提高效率。每个题目都能通过这种方法在O(log n)的时间复杂度内解决。
算法之常见二分查找法题目
ChenYiRan123456的博客
12-27 1019
二分查找法是比较常见的一种算法，下面我列举的题目都是常见的二分算法题目。剑指 Offer II 072. 求平方根 leedcode 35. 搜索插入位置leedcode 367. 有效的完全平方数leedcode 34. 在排序数组中查找元素的第一个和最后一个位置
C语言二分查找算法及实现代码
09-02
二分查找，又称折半查找，是一种在有序数组中寻找特定元素的搜索算法。它的基本原理是通过不断将待搜索的区间减半，快速定位到目标元素。在每次比较时，算法都会取数组的中间元素与目标值进行比较，根据比较结果决定...
面试高频：二分法，多题多图，一次讲个明白
u014339447的博客
11-23 1207
基础算法一：二分法，你思考过这些问题吗？ 如何优雅的处理边界条件？ 一定要数据有序时才能使用二分吗？ 如何优雅的证明二分法的时间复杂度是O(logn)？ 如果这几个问题你已经完全掌握了，可以点击右上角关闭。如果想听听我的心得，请读完下面内容。 1. 什么是二分法？ ​ 二分法(Bisection method)，即一分为二的的方法。对于在区间[a,b]上连续不断且满足f(a)*f(b)<0的函数y=f(x),通过不断地把函数f(x)的零点所在区间二等分，使区间两个端点逐步逼近零点，进而得到零点的近似值
二分法 以及简单题目运用-自我回顾~~~
luka1910的博客
11-17 637
所谓二分，即通过一个性质Check把一个区间划分为两部分，一部分为满足这个性质的区间，另一部分为不满足这个性质的区间 而二分法的具体使用即找到满足Check性质和不满足Check性质的两个区间之间的边界 我们可以粗略的理解为寻找Meeting Last 和 None Meeting Begining 即寻找满足性质区间中的最后一个(ML)，和 不满足性质区间的第一个(NB) 于是，我们可以使用以下两套二分模板 查找NB时的二分模板 int bsearch_1(int l, int r)..
在一个有序数组中查找具体某个数字。可以用二分查找。有用到sizeof
weixin_59470281的博客
10-06 339
#define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> int main() { int arr[] = { 1,2,3,4,5,6,7,8,9,10 }; //这里arr这个数组我们并不知道它有多少个元素。 int k = 7; int sz = sizeof(arr) / sizeof(arr[0]); // arr数组占的总空间/arr数组中一个元素所占的空间 // ==这个arr数组中元素的个数。 int left =.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值