算法学习二分法解题框架

最新推荐文章于 2022-11-27 14:27:21 发布

&LinFans

最新推荐文章于 2022-11-27 14:27:21 发布

阅读量229

点赞数

分类专栏：算法学习

原文链接：https://github.com/labuladong/fucking-algorithm/blob/master/%E7%AE%97%E6%B3%95%E6%80%9D%E7%BB%B4%E7%B3%BB%E5%88%97/%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE%E8%AF%A6%E8%A7%A3.md

版权

算法学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

二分查找

##二分查找解题框架
注意：

尽量不用else，用else if把每种情况说清楚；
left+（right-left）/2,防止（left+right）/2太大而导致溢出。
其中…标记的地方，就是可能出现的细节问题。

int binarySearch(int[] nums, int target) {
    int left = 0, right = ...;

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

寻找一个数（基本的二分搜索）

int binarySearch(int []nums,int target)
{
	if(nums.length<=0)
		return -1;
	//搜索区间 [start,end]
	int start=0;
	int end=nums.length-1;//注意
	//中止条件 start=end+1 [end+1,end]确实不存在
	//如果是start<end 中止条件start=end 那么[end,end]就结束需要加上补丁
	while(start<=end){
		int mid=start+(end-start)/2;
		if(nums[mid]==target)
			return mid;
		else if(nums[mid]<target)
			start=mid+1;//注意
		else if(nums[mid]>target)
			end=mid-1;//注意
	}
	return -1;
}

为什么while中的循环条件是<=而不是< ?
答：因为初始化 right 的赋值是 nums.length - 1，即最后一个元素的索引，而不是 nums.length。
这二者可能出现在不同功能的二分查找中，区别是：前者相当于两端都闭区间 [left, right]，后者相当于左闭右开区间 [left, right)，因为索引大小为 nums.length 是越界的。
我们这个算法中使用的是前者 [left, right] 两端都闭的区间。这个区间其实就是每次进行搜索的区间。
什么时候应该停止搜索呢？当然，找到了目标值的时候可以终止：
```
if(nums[mid] == target)
    return mid; 
```
但如果没找到，就需要 while 循环终止，然后返回 -1。那 while 循环什么时候应该终止？搜索区间为空的时候应该终止，意味着你没得找了，就等于没找到嘛。

while(left <= right) 的终止条件是 left == right + 1，写成区间的形式就是 [right + 1, right]，或者带个具体的数字进去 [3, 2]，可见这时候区间为空，因为没有数字既大于等于 3 又小于等于 2 的吧。所以这时候 while 循环终止是正确的，直接返回 -1 即可。

while(left < right) 的终止条件是 left == right，写成区间的形式就是 [left, right]，或者带个具体的数字进去 [2, 2]，这时候区间非空，还有一个数 2，但此时 while 循环终止了。也就是说这区间 [2, 2] 被漏掉了，索引 2 没有被搜索，如果这时候直接返回 -1 就是错误的。

当然，如果你非要用 while(left < right) 也可以，我们已经知道了出错的原因，就打个补丁好了：
```
//...
while(left < right) {
    // ...
}
return nums[left] == target ? left : -1;
```
为什么left=mid+1,right=mid-1?
刚才明确了「搜索区间」这个概念，而且本算法的搜索区间是两端都闭的，即 [left, right]。那么当我们发现索引 mid 不是要找的 target 时，下一步应该去搜索哪里呢？

当然是去搜索 [left, mid-1] 或者 [mid+1, right] 对不对？因为 mid 已经搜索过，应该从搜索区间中去除。
此算法的缺陷
比如说给你有序数组 nums = [1,2,2,2,3]，target 为 2，此算法返回的索引是 2，没错。但是如果我想得到 target 的左侧边界，即索引 1，或者我想得到 target 的右侧边界，即索引 3，这样的话此算法是无法处理的。

这样的需求很常见，你也许会说，找到一个 target，然后向左或向右线性搜索不行吗？可以，但是不好，因为这样难以保证二分查找对数级的复杂度了。

左右侧边界统一写法

int binary_search(int[] nums, int target) {
    int left = 0, right = nums.length - 1; 
    while(left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1; 
        } else if(nums[mid] == target) {
            // 直接返回
            return mid;
        }
    }
    // 直接返回
    return -1;
}

int left_bound(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else if (nums[mid] == target) {
            // 别返回，锁定左侧边界
            right = mid - 1;
        }
    }
    // 最后要检查 left 越界的情况
    if (left >= nums.length || nums[left] != target)
        return -1;
    return left;
}


int right_bound(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else if (nums[mid] == target) {
            // 别返回，锁定右侧边界
            left = mid + 1;
        }
    }
    // 最后要检查 right 越界的情况
    if (right < 0 || nums[right] != target)
        return -1;
    return right;
}

1、分析二分查找代码时，不要出现 else，全部展开成 else if 方便理解。
2、注意「搜索区间」和 while 的终止条件，如果存在漏掉的元素，记得在最后检查。
3、如果将「搜索区间」全都统一成两端都闭，好记，只要稍改 nums[mid] == target 条件处的代码和返回的逻辑即可。

例题

1.搜索旋转排序数组

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

示例 1:

输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4
示例 2:

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

思路和算法

题目要求算法时间复杂度必须是 O(\log n)O(logn) 的级别，这提示我们可以使用二分搜索的方法。

但是数组本身不是有序的，进行旋转后只保证了数组的局部是有序的，这还能进行二分搜索吗？答案是可以的。

可以发现的是，我们将数组从中间分开成左右两部分的时候，一定有一部分的数组是有序的。拿示例来看，我们从 6 这个位置分开以后数组变成了 [4, 5, 6] 和 [7, 0, 1, 2] 两个部分，其中左边 [4, 5, 6] 这个部分的数组是有序的，其他也是如此。

这启示我们可以在常规二分搜索的时候查看当前 mid 为分割位置分割出来的两个部分 [l, mid] 和 [mid + 1, r] 哪个部分是有序的，并根据有序的那个部分确定我们该如何改变二分搜索的上下界，因为我们能够根据有序的那部分判断出 target 在不在这个部分：

如果 [l, mid - 1] 是有序数组，且 target 的大小满足 [\textit{nums}[l],\textit{nums}[mid])[nums[l],nums[mid])，则我们应该将搜索范围缩小至 [l, mid - 1]，否则在 [mid + 1, r] 中寻找。
如果 [mid, r] 是有序数组，且 target 的大小满足 (\textit{nums}[mid+1],\textit{nums}[r]](nums[mid+1],nums[r]]，则我们应该将搜索范围缩小至 [mid + 1, r]，否则在 [l, mid - 1] 中寻找。
在这里插入图片描述

需要注意的是，二分的写法有很多种，所以在判断 target 大小与有序部分的关系的时候可能会出现细节上的差别。

class Solution {
public:
	int search(vector<int>& nums, int target) {
        if(nums.size()<=0)
            return -1;
        int left=0;
        int right=nums.size()-1;
        
        while(left<=right)
        {
            int mid=left+(right-left)/2;
            if(nums[mid]==target)return mid;
            else if(nums[0]<=nums[mid])//判断如果0到mid为有序序列;注意必须<=nums[mid]如果<nums[mid]:那么当0=mid时另一个区间就包含了最大值nums[mid]
            {
                if(target<nums[mid]&&target>=nums[0])right=mid-1;//如果target在[0,mid)之间
                else left=mid+1;
            }else{//如果mid到end为有序序列
                if(target>nums[mid]&&target<=nums[nums.size()-1])left=mid+1;//如果target在(mid,end-1]之间
                else right=mid-1;
            }
            
        }
         return -1;
    }  
};

class Solution {
public:
	int search(vector<int>& nums, int target) {
        if(nums.size()<=0)
            return false;
        int left=0;
        int right=nums.size()-1;
        
        while(left<=right)
        {
            while(left!=right&&nums[left]==nums[right])right--;//
            int mid=left+(right-left)/2;
            if(nums[mid]==target)return true;
            else if(nums[0]<=nums[mid])
            {
                if(target<nums[mid]&&target>=nums[left])right=mid-1;
                else left=mid+1;
            }else{
                if(target>nums[mid]&&target<=nums[right])left=mid+1;
                else right=mid-1;
            }
            
        }
         return false;
    }
};

2.分割数组的最大值

给定一个非负整数数组和一个整数 m，你需要将这个数组分成 m 个非空的连续子数组。设计一个算法使得这 m 个子数组各自和的最大值最小。

注意:
数组长度 n 满足以下条件:

1 ≤ n ≤ 1000
1 ≤ m ≤ min(50, n)
示例:

输入:
nums = [7,2,5,10,8]
m = 2

输出:
18

解释:
一共有四种方法将nums分割为2个子数组。
其中最好的方式是将其分为[7,2,5] 和 [10,8]，
因为此时这两个子数组各自的和的最大值为18，在所有情况中最小。

思路：二分的左右界不仅仅可以是数组的下标，还可以是某一个需要查找值的范围。本题因为最小和的范围在数组中最大值到所有值的和中间，所以二分的上下界就是这个范围。用二分查找这个范围，开始累加数组，看数组中如果全部小于mid最多会有多少组子数组，如果超过m说明mid设置小了，如果不超过m说明可能设置大了或者找到了目标值，这时候就缩小搜索范围；

class Solution {
public:
    int splitArray(vector<int>& nums, int m) {
        if(nums.size()<=0||m<=0)return -1;
        long high=0;
        long low=0;
        for(auto num:nums){
            high+=num;
            low=low>num?low:num;
        }

        while(low<=high)//，
        //如果有等号，就是low=high+1时退出循环.
        {
           long mid=(low+high)/2;
           int cnt=1;
           long temp=0;
           for(auto num:nums)
           {
               temp+=num;
               if(temp>mid)
                {
                    temp=num;
                    cnt++;
                }
           } 
           if(cnt>m)low=mid+1;
           else high=mid-1;
        }
        return low;
    }
};

while(low<high)//while条件如果没有等于号，就是low=high时退出循环,mid有可能就是答案，所以high=mid
{
...
high=mid;
}

while(low<=high)//while条件如果有等于号，就是low=high+1时退出循环,但是high=mid-1后，如果mid才是答案的话low=high的时候并不会终止，而是会发生cnt>m的情况，所以low还是会在加一
{
...
low=mid+1;
high=mid-1;
}

&LinFans

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
算法学习二分法解题框架

二分查找##二分查找解题框架注意：尽量不用else，用else if把每种情况说清楚；left+（right-left）/2,防止（left+right）/2太大而导致溢出。其中…标记的地方，就是可能出现的细节问题。int binarySearch(int[] nums, int target) { int left = 0, right = ...; while(...) { int mid = left + (right - left) / 2;
复制链接

扫一扫