算法-二分法应用技巧

level 1

一个非常简单的二分应用问题，假设你有一个升序数组，然后让你去search一个target的index
比如

vector<int> arr({1,2,3,4,5,6,7,8});

使用二分法就比较简单了

        vector<int> arr({1,2,3,4,5,6,7,8,9});
        int l = 0;
        int r = arr.size() - 1;
        int v = 7;

        while(l<r){
            int mid = (r - l)/2+l;
            if(v == arr[mid]){
                cout<<mid;
                break;
            }
            if(v<arr[mid]){
                r = mid - 1;
            }
            if(v>arr[mid]){
                l = mid+1;
            }
        }

二分法一般针对的是有序数组
它的核心思想在于将结果集合以log的速度坍缩到一个范围，直到找到它。

level 2

如果有序数组发生了旋转: 旋转数组，然后让你再去定位新数组里面target的index，问题就会变得有些艰难。

比如一下这串从0124567旋转后的新数组

arr = [4,5,6,7,0,1,2]

我们尝试serach一下raget = 6所在的index
虽然经过旋转，但是局部却是保存了有序的性质，可以尝试使用二分法

情况 1

left = 0,right = 6,mid = 3,也就是arr[3] = 7,我们发现target < arr[mid]，于是我们可以坍缩选择集合，从[0,6]->[0,3]，然后尝试下

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l = 0;
        int r = nums.size() - 1;
        int mid = -1;
        while(l<=r){
            mid = (r - l)/2+l;
            if(target == nums[mid]){
                cout<<mid;
                break;
            }
            if(target<nums[mid]){
                r = mid - 1;
            }
            if(target>nums[mid]){
                l = mid+1;
            }
        }
        return mid;
    }
};

情况2

当然，这个结果对于6而言是没问题的，我们尝试检索0所在的索引

为什么会发生这种事情？
我们输出了它在这个过程中发生的事情

一开始的搜索域是[0,6]
第二次的搜索域是[0,2]??不应该是[4,6]才对吗?
于是你恍然大悟
旋转后的场景变得复杂，所以条件也需要增加，从而确保在遇到这种情况能够将搜索域转移到[4,6]，那么条件是什么呢?
继续观察两个搜素域
[4,5,6],[0,1,2]
我们有理由观察到，target分给哪一个搜索域的基础条件是该子搜索域的左界要>=target，同时右界要<=target,显然[4,5,6]不符合条件，而0,1,2符合条件

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l = 0;
        int r = nums.size() - 1;
        int mid = -1;
        while(l<=r){
            mid = (r - l)/2+l;
            if(target == nums[mid]){
                cout<<mid;
                break;
            }
            //左子域
            if(target>= nums[l]&&target<= nums[mid-1]){
                r = mid - 1;
            }
            //右子域
            if(target>= nums[mid+1]&&target<= nums[r]){
                l = mid+1;
            }
            // if(target<nums[mid]){
            //     r = mid - 1;
            // }
            // if(target>nums[mid]){
            //     l = mid+1;
            // }
        }
        return mid;
    }
};

那么问题是不是就解决了呢?

情况3

这个时候，我们将target = 6，然后搜索

淦!
为什么出现这种问题了呢？
第一次二分时，分裂出了两个域[4,5,6],[0,1,2]，与此同时，我们从新修改的代码可以推测出我们的target同时满足在两个域的条件

显然，当满足其中一个域，就不能再满足另外一个域，所以我们可以定义一个code来分辨选择哪个域

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l = 0;
        int r = nums.size() - 1;
        int mid = -1;
        while(l<=r){
            mid = (r - l)/2+l;
            if(target == nums[mid]){
                cout<<mid;
                break;
            }
            int code = 0;
            //左子域
            if(target>= nums[l]&&target<= nums[mid-1]){
                code = 1;
            }
            //右子域
            if(target>= nums[mid+1]&&target<= nums[r]){
                l = mid+1;
                code = 2;
            }
            if(code == 1){
                r = mid - 1;
            }
            if(code == 2){
                l = mid+1;
            }
        }
        return mid;
    }
};

情况4

将代码丢到leetcode去跑，一个新的测试案例的失败,让问题陡然变得复杂起来
我们发现3 既不属于code = 1的情况，也不属于code = 2的情况，那么…再加一句代码

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

情况 5

此时mid = 2;
两域为[3,4],[6,1,2]，我们发现，此时的target = 2既不满足左子域的入狱条件也不满足右子域的入狱条件，显然，这是第四种情况，也就是，此时的目标值一定会在两域中左界>又界的域中

我们对code == 0的情况进一步处理

            if(code == 0){
                if(nums[l]>nums[mid -1]){
                    r = mid - 1;
                    continue;
                }
                if(nums[mid+1]>nums[r]){
                    l = mid+1;
                    continue;
                }
                return -1;
            }

情况6

当mid == 0的时候，此时，如果进行下界域arr[mid-1]的判断一定会崩

            mid = (r - l)/2+l;
            if(mid == 0){
                if(nums[r] == target){
                    return r;
                }
                if(nums[l] == target){
                    return l;
                }
                return -1;
                
            }

情况7

存在一个mid，满足了入狱情况，但该域并不存在target

解决了7个情况后，你大概得到一份代码：

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l = 0;
        int r = nums.size() - 1;
        int mid = -1;
        while(l<=r){
            mid = (r - l)/2+l;
            if(mid == 0){
                if(nums[r] == target){
                    return r;
                }
                if(nums[l] == target){
                    return l;
                }
                return -1;
                
            }
            if(target == nums[mid]){
                cout<<mid;
                break;
            }
            int code = 0;
            //左子域
            if(target>= nums[l]&&target<= nums[mid-1]){
                code = 1;
            }
            //右子域
            if(target>= nums[mid+1]&&target<= nums[r]){
                l = mid+1;
                code = 2;
            }
            if(code == 1){
                r = mid - 1;
            }
            if(code == 2){
                l = mid+1;
            }
            if(code == 0){
                if(nums[l]>nums[mid -1]){
                    r = mid - 1;
                    continue;
                }
                if(nums[mid+1]>nums[r]){
                    l = mid+1;
                    continue;
                }
                return -1;
            }
        }
        if(nums[mid] == target){
            return mid;
        }
        return -1;
    }
};

md…细节狂魔