程序博客网 > 我知我行征文

二分查找全集

来源：互联网 发布：我知我行征文 编辑：程序博客网 时间：2024/06/06 09:51

1，原始二分查找

题目：给定一个有序（非降序）数组A，求任意一个i使得A[i]等于target，不存在则返回-1

例如：[2,4,6,8,9]找(4) 位置1

1.1 递归版

[cpp] view plaincopy
  1. int bSearch(int a[], int low, int high, int target){  
  2.     if(low > high)  
  3.         return -1;  
  4.     int mid = (low + high)/2;  
  5.     if(target<a[mid])  
  6.         return bSearch(a,low,mid-1,target);  
  7.     else if(target>a[mid])  
  8.         return bSearch(a,mid+1,high,target);  
  9.     //if(target == a[mid])  
  10.     return mid;  
  11. }  

1.2 迭代版

[cpp] view plaincopy
  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. }  

1.3 返回插入位置

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

[cpp] view plaincopy
  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 -(low+1);  
  16. }  

之所以返回-（low+1）而不是直接返回-low是因为low可能为0，如果直接返回-low就无法判断是正常返回位置0还是查找不成功返回的0。

2，含重复元素，求=target的最小一个

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

例如：A[2,4,6,8,8,8,9]求8得最小位置3

[cpp] view plaincopy
  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.         {  
  10.             if(mid > 0 && A[mid-1] == target)  
  11.                 high = mid-1;             
  12.             else   
  13.                 return mid;  
  14.         }  
  15.         else if(A[mid] < target)  
  16.             low = mid+1;               
  17.         else // A[mid] > target  
  18.             high = mid-1;             
  19.     }  
  20.     return -1;    
  21. }  

3，含重复元素，求=target的最大一个

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

例如：A[2,4,6,8,8,8,9]求8得最大位置5

[cpp] view plaincopy
  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.         {  
  10.             if(mid < n && A[mid+1] == target)  
  11.                 low = mid+1;             
  12.             else   
  13.                 return mid;  
  14.         }  
  15.         else if(A[mid] < target)  
  16.             low = mid+1;               
  17.         else // A[mid] > target  
  18.             high = mid-1;             
  19.     }  
  20.     return -1;    
  21. }  

4，含重复元素，求<target的最大一个

问题：给定一个有序（非降序）数组A，可含有重复元素，求最大的i使得A[i]小于target，不存在则返回-1
例如：A[2,4,6,8,8,8,9]求9得最大位置5
问题转化：含重复元素，求2【=target的最小一个】的前一个。
[cpp] view plaincopy
  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.         {  
  10.             if(mid > 0 && A[mid-1] == target)  
  11.                 high = mid-1;             
  12.             else   
  13.                 return (mid==0)?-1:mid-1;  
  14.         }  
  15.         else if(A[mid] < target)  
  16.             low = mid+1;               
  17.         else // A[mid] > target  
  18.             high = mid-1;             
  19.     }  
  20.     return -1;    
  21. }  

5，含重复元素，求>target的最小一个

问题：给定一个有序（非降序）数组A，可含有重复元素，求最小的i使得A[i]大于target，不存在则返回-1
例如：A[2,4,6,8,8,8,9]求6的最小位置3
问题转化：含重复元素，求3【=target的最大一个】的后一个。
[cpp] view plaincopy
  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.         {  
  10.             if(mid < n && A[mid+1] == target)  
  11.                 low = mid+1;             
  12.             else   
  13.                 return (mid==n)?-1:mid+1;  
  14.         }  
  15.         else if(A[mid] < target)  
  16.             low = mid+1;               
  17.         else // A[mid] > target  
  18.             high = mid-1;             
  19.     }  
  20.     return -1;    
  21. }  

6，含重复元素，求=target的出现次数

问题：给定一个有序（非降序）数组A，可含有重复元素，求target在数组中出现的次数。
例如：A[2,4,6,8,8,8,9]求8的出现次数3

求出第一次出现位置和最后一次出现位置。由于前面都已实现，这里不多解释。请参考实现代码与注释
[cpp] view plaincopy
  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，可含有重复元素，求绝对值最小的元素的位置
例如：A[-4,-2,-1,2,3,8,9]求结果为2
[cpp] view plaincopy
  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. }  

8，
问题：给定一个有序（非降序）数组A和一个有序（非降序）数组B，可含有重复元素，求两个数组合并结果中的第k(k>=0)个数字。
这个题目出现了两个数组，有序的，不管怎样我们就应该首先考虑二分查找是否可行。若使用顺序查找，时间复杂度最低为O(k)，就是类似归并排序中的归并过程。使用用二分查找时间复杂度为O(logM+logN)。二分查找的具体实现过程请参考实现代码与注释。
[cpp] view plaincopy
  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. }  
9
问题：

一个有序（升序）数组，没有重复元素，在某一个位置发生了旋转后，求target在变化后的数组中出现的位置，不存在则返回-1
如 0 1 2 4 5 6 7 可能变成 4 5 6 7 0 1 2


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

10，
问题：一个有序（升序）数组，没有重复元素，在某一个位置发生了旋转后，求最小值所在位置
如果中间元素小于左端元素，则最小值在左半区间内（包含中间元素）；如果中间元素大于右端元素，则最小值在右半区间内（包含中间元素）。请参考实现代码与注释。
[cpp] view plaincopy
  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. }  

11,
问题：

一个有序（升序）数组，没有重复元素，在某一个位置发生了旋转后，求第k(k > 0)小元素的位置


我们可以利用上一题的解答，求出最小值所在位置后，便可以求出第k小元素。请参考实现代码与注释
[cpp] view plaincopy
  1. int searchKthInRotatedArray(int A[], int n, int k)   
  2. {  
  3.     int posMin = searchMinInRotatedArray(A, n);  
  4.     return (posMin+k-1)%n;  
  5. }  

12，查找旋转数组的最小数字

题目：即找分界点，比如3 4 5 1 2，返回的是位置3。
以题目中的旋转数组为例，{3,4,5,1,2}，我们可以有序数组经过旋转以后被分割为两段有序的数组，比如此处被分为{3,4,5}{1,2}这样连个数组，并且前半段数组中的数字肯定大于等于后半段的数组。我们找中间元素a[mid]，让其跟元素首元素a[low]和尾元素a[high]比较，如果大于首元素a[low]，则中间元素属于前半段有序数组；如果小于尾元素a[high]，那么中间元素就是后半段的元素。
这里我们设定两个指针start和end分别指向数组的首尾元素，然后当start指向前半段最后一个元素，end指向后半段第一个元素，这是程序就找到了数组中的最小元素，就是end指向的那个数，程序的出口就是 end-start==1。
[cpp] view plaincopy
  1. int bSearchMinValue(int a[], int low, int high){  
  2.     //终止递归条件是low和high差1，原因是后面mid都不是+1-1处理的  
  3.     if(low+1==high)  
  4.         return high;  
  5.     int mid = (low + high)/2;  
  6.   
  7.     if(a[mid]>a[low])//左侧有序，在右边找分界点  
  8.         return bSearchMinValue(a,mid,high);  
  9.     if(a[mid]<a[high])//右侧有序，在左边找分界点  
  10.         return bSearchMinValue(a,low,mid);  
  11.     return -1;  
  12. }  
特别注意，如果数组a不是旋转数组，则会错误。

13，查找旋转数组的任意数字

http://hi.baidu.com/nicker2010/item/4d4f71145532a234b83180a7
例如：仔细分析该问题，可以发现，每次根据low和high求出mid后，mid左边（[low, mid]）和右边（[mid, high]）至少一个是有序的。
a[mid]分别与a[left]和a[right]比较，确定哪一段是有序的。
如果左边是有序的，若target<a[mid]且target>a[left], 则right=mid-1；其他情况，left =mid+1；
如果右边是有序的，若target> a[mid] 且target<a[right] 则left=mid+1；其他情况，right =mid-1；
[cpp] view plaincopy
  1. //旋转数组的二分查找  
  2. int bSearchMinValue(int a[], int low, int high, int target){  
  3.       
  4.     int mid = (low + high)/2;  
  5.       
  6.     //就是a[mid]  
  7.     if(target == a[mid])  
  8.         return mid;  
  9.           
  10.     if(a[mid]>=a[low]){//左侧有序，在右边有分界点  
  11.         //在左侧有序的之中  
  12.         if(target>=a[low]&&target<a[mid])  
  13.             return bSearchMinValue(a,low,mid-1,target);  
  14.         //在右侧有分界点之中  
  15.         else  
  16.             return bSearchMinValue(a,mid+1,high,target);  
  17.     }  
  18.     else if(a[mid]<=a[high]){//右侧有序，在左边有分界点  
  19.         //在右侧有序的之中  
  20.         if(target>a[mid]&&target<=a[high])  
  21.             return bSearchMinValue(a,mid+1,high,target);  
  22.         //在左侧有分界点之中  
  23.         else  
  24.             return bSearchMinValue(a,low,mid-1,target);  
  25.     }  
  26.     return -1;  
  27. }  
0 0
我知我行征文 我知我行征文
原创粉丝点击
热门IT博客
解压缩zip linux解压缩zip linux
storyboard quick macstoryboard quick mac
易我数据恢复怎么用
mui template.js
pta编程7-1求数列之和
保定淘宝运营培训
淘宝店铺违反广告法
windows安全配置手册
linux 流程图工具
java 执行多条dos命令
云计算的特点以为中心
windows旧系统文件
网络语内涵是什么意思
python 日记
普中科技单片机教程
单片机怎么初始化
神话网络
股票专业分析软件
ubuntu安装wine1.9
各个星星知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 山西省农村信用社 山西省第二人民医院 山西省应急管理厅 山西的美食 山西菜 山西菜的招牌菜 山西特色菜 山西会馆许坦西街 山西盂县金龙街宾馆 山西方言大全 山西话方言大全 山西话方言我爱你 山西话方言发音大全 阳泉话 太原话 太原县城 山西蜂蜜 山西柿子 山西花椒 山西陈醋价格 山西水塔老陈醋价格 山西老陈醋批发 山西老陈醋排名 山西老陈醋品牌 山西紫林陈醋 山西陈醋什么牌子好 山西醋湖 山西醋排名 山西醋哪个品牌的好吃 山西水塔醋业股份有限公司 山西醋哪个牌子好 山西醋品牌 山西醋多少钱一斤 山西醋文化 山西醋厂 太原东湖醋厂 太原醋 山西 醋 山西的醋 蜂蜜和醋 山西手工醋

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里