这篇博客探讨了二分查找在实际编程中的应用和常见问题，特别是在处理有序数组时的边界条件和死循环预防。文章通过三个具体问题（查找元素范围、求唯一元素、找旋转数组中特定元素）详细阐述了解决策略，强调了在处理过程中注意数组的旋转、边界和递归使用。
查找
二分查找看似简单，思路也很清晰，但是在实际编程很容易因为各种边界问题而出问题，尤其是当区间中最后只剩下一两个数时，非常容易陷入死循环。经常结合递归来解题。
练手题：69（数学解法） 34 540 4
-
34：在排序数组中查找元素的第一个和最后一个位置
相当于实现C++ 里的 lower_bound 和 upper_bound 函数。我们先对半分，然后根据中间元素向两边进行扩展（或单边）。要非常注意死循环问题和没找到的情况。
class Solution { public: int low_bound(vector<int>& nums, int target,int left,int right){ if(left>right) return -1; if(left==right)//防止出现死循环 return nums[left]==target?left:-1; int mid=(left+right)/2;//不能+1，否则也会死循环 if(nums[mid]<target) return low_bound(nums,target,mid+1,right); else return low_bound(nums,target,left,mid);//要包括mid } int high_bound(vector<int>& nums, int target,int left,int right){ if(left>right)//没找到 return -1; if(left==right){//防止出现死循环 //return left; //错误！ return nums[left]==target?left:-1; } //注意，这里如果用(left+right)/2会出现死循环：考虑5 7 7 8 8 10 最右侧的部分 //导致区间总是找偏左的那个数 int mid=(left+right)/2+1; if(nums[mid]>target) return high_bound(nums,target,left,mid-1); else return high_bound(nums,target,mid,right);//要包括mid } vector<int> searchRange(vector<int>& nums, int target) { //相当于自己实现low_bound和hige_bound vector<int> bound(2,-1); bound[0]=low_bound(nums,target,0,nums.size()-1); bound[1]=high_bound(nums,target,0,nums.size()-1); return bound; } }; -
540：求有序数组中只出现一次的元素（其余都出现2次）
不难，就是有个小小的边界处理问题。by the way，位运算也ok
class Solution { public: //有坑啊孩子们 1 1 2 3 3 4 4 / 1 1 2 3 3 4 4 5 5 int singleNonDuplicate(vector<int>& nums) { if(nums.size()==1) return nums[0]; int left=0,right=nums.size()-1; //程序保证right-left+1必然为奇数 while(left<right){ int mid=(left+right)/2; if(nums[mid]!=nums[mid-1] && nums[mid]!=nums[mid+1]) return nums[mid]; if(nums[mid]==nums[mid-1]){ if((mid-left)%2) left=mid+1; else//左侧扣掉当前数对后为奇数，向左走 right=mid-2; } else{ if((mid-left)%2) right=mid-1; else//左侧扣掉当前数对后为偶数，向右走 left=mid+2; } } //退出条件 left==right return nums[left]; } }; -
4：
救大命，好混乱，需要对两个数组同时进行二分搜索。
class Solution { public: int getKthElement(const vector<int>& nums1, const vector<int>& nums2, int k) { /* 主要思路：要找到第 k (k>1) 小的元素，那么就取 pivot1 = nums1[k/2-1] 和 pivot2 = nums2[k/2-1] 进行比较 * 这里的 "/" 表示整除 * nums1 中小于等于 pivot1 的元素有 nums1[0 .. k/2-2] 共计 k/2-1 个 * nums2 中小于等于 pivot2 的元素有 nums2[0 .. k/2-2] 共计 k/2-1 个 * 取 pivot = min(pivot1, pivot2)，两个数组中小于等于 pivot 的元素共计不会超过 (k/2-1) + (k/2-1) <= k-2 个 * 这样 pivot 本身最大也只能是第 k-1 小的元素 * 如果 pivot = pivot1，那么 nums1[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums1 数组 * 如果 pivot = pivot2，那么 nums2[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums2 数组 * 由于我们 "删除" 了一些元素（这些元素都比第 k 小的元素要小），因此需要修改 k 的值，减去删除的数的个数 */ int m = nums1.size(); int n = nums2.size(); int index1 = 0, index2 = 0; while (true) { // 边界情况 if (index1 == m) { return nums2[index2 + k - 1]; } if (index2 == n) { return nums1[index1 + k - 1]; } if (k == 1) { return min(nums1[index1], nums2[index2]); } // 正常情况 int newIndex1 = min(index1 + k / 2 - 1, m - 1); int newIndex2 = min(index2 + k / 2 - 1, n - 1); int pivot1 = nums1[newIndex1]; int pivot2 = nums2[newIndex2]; if (pivot1 <= pivot2) { k -= newIndex1 - index1 + 1; index1 = newIndex1 + 1; } else { k -= newIndex2 - index2 + 1; index2 = newIndex2 + 1; } } } double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) { int totalLength = nums1.size() + nums2.size(); if (totalLength % 2 == 1) { return getKthElement(nums1, nums2, (totalLength + 1) / 2); } else { return (getKthElement(nums1, nums2, totalLength / 2) + getKthElement(nums1, nums2, totalLength / 2 + 1)) / 2.0; } } };
旋转数组问题
**旋转数组：**原本增序的数组被首尾相连后按某个位置断开（ [1,2,2,3,4,5] → [2,3,4,5,1,2]，在一位和二位断开）
一定一定画图画清除再做！一定一定想清楚再写！一定一定理解到位！
练手题：81 154
-
81：给定一个值，判断这个值是否存在于这个为旋转数组中。
对于当前的中点， 如果它指向的值小于等于右端，那么说明右区间是排好序的；反之，那么说明左区间是排好序的。 如果目标值位于排好序的区间内，我们可以对这个区间继续二分查找；反之，我们对于另一半区 间继续二分查找。
不能！一开始就根据目标查找数字定向左段还是右段，而应该整体看待。我们的目标并不是断点在哪段，而是哪段有序。有序的片段正常二分查找，否则整段按乱序的思想查找。
**注意，因为数组存在重复数字，如果中点和左端的数字相同，我们并不能确定是左区间全部 相同，还是右区间完全相同。**在这种情况下，我们可以将左右端点均向中间移一位，然后继续进行二分查找。
给出一些特殊的测试样例： 7 7 7 8 7 和 7 8 7 7 7
class Solution { public: bool search(vector<int>& nums, int target) { int len=nums.size()-1; if(!len) return nums[0]==target; if(target==nums[0]) return true; int left=1,right=len; /* 我原来的想法是：先判断目标值在左右两边哪个区间，然后进行分类讨论，麻烦了！会出很多问题 即if(target>nums[0]){//向右侧找 while() } else{ while()} 直接一个大的while循环，内侧寻找是否有序就好了 */ // if(target>nums[0]){//向右侧找 while(left<=right){ int mid=(left+right)/2;//找中间 if(nums[mid]==target) return true; //本题关键：转折点在哪里！ //无法分辨哪个区间有序，即方向不清时，即无法判断转折点位置 if(nums[left]==nums[right] && nums[left]==nums[mid]){ ++left; --right;//缩短区间，注意最终有可能是1 1 1 2，即不符合题目原定义的类型 //我们用顺一点的思路，每次只缩短一边，保证缩短后的依然符合原定义 //证明：nums[left+1]>=nums[left]>=nums[right] 转折点不是left+1时 //转折点是left+1,如5 4 5 5 5 啊……一样算了还是加上把 } //把区间换一种方式来看，即把某个区间内的数整体移到右边，剩余数合并后放在左边 //这样下面的式子就很好理解了 //默认已知nums[left]>=nums[right]……似乎也不是那么默认，如特殊情况 //该方向取等时：5 5 5 3 4 ，转折点依然在左侧 //说明左侧排序排好了，符合 // else if(nums[mid]<=nums[left]){//转折点必然在左侧，右侧升序 else if(nums[mid]<=nums[right]){//改成这个才对？ if(nums[mid]<target && target<=nums[right]){ //介于中点和右侧之间必然在右侧 left=mid+1; } else{//大于right或小于mid的都在左侧了 right=mid-1; } } // else if(nums[mid]>nums[right]){//转折点必然在右侧，左侧有序 //上面那句话1 0 1 1 1会死循环 else{ if(nums[mid]>target && target>=nums[left]){ //介于中点和左侧，之间必然在左侧 right=mid-1; } else{//大于right或小于mid的都在左侧了 left=mid+1; } } } return false; } }; -
154：寻找旋转数组的最小值
用递归明显阳间了不少
class Solution { public: //用递归 int fMin(vector<int>& nums,int left,int right){ if(left==right)//left>right时还没考虑,感觉不用考虑 return nums[left]; //对剩余两个元素的情况也特殊处理，否则越界后返回值很麻烦 //或者把全部都传成mid而不是mid-1，left+1全部都是left之类的 if(right-left==1) return min(nums[left],nums[right]); int mid=(left+right)/2; if(nums[left]<nums[right])//旋转n次时 return nums[left]; if(nums[left]==nums[right]){//左右相等 if(nums[left]==nums[mid])//无法确定区间 //如果是2 2 return min(fMin(nums,left,mid-1),fMin(nums,mid+1,right)); if(nums[left]<nums[mid])//说明左侧区间升序了 return fMin(nums,mid+1,right);//右侧找，不用mid，因为有right return fMin(nums,left+1,mid);//右侧升序了，则右侧的最小值用mid代表 //如果旋转点在左侧，left可以去掉 } //不加else也行，默认nums[left]>nums[right] //直接从右侧开始找就行 if(nums[mid]<=nums[right]) return fMin(nums,left+1,mid); else return fMin(nums,mid+1,right); } int findMin(vector<int>& nums) { if(nums.size()==1) return nums[0]; return fMin(nums,0,nums.size()-1); } };官方：
class Solution { public: int findMin(vector<int>& nums) { int low = 0; int high = nums.size() - 1; while (low < high) { int pivot = low + (high - low) / 2; if (nums[pivot] < nums[high]) { high = pivot; } else if (nums[pivot] > nums[high]) { low = pivot + 1; } else { high -= 1; } } return nums[low]; } };
扫一扫
1105
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
