算法笔记-二分法(一)

二分查找法是最常用的算法，可以在有序数组中查找特定的元素
其时间复杂度为O(logn)

非递归的模板如下:

    int search(vector<int>& nums, int target) {
        int start = 0, end = nums.size() - 1;
        while(start +1 < end){
            int mid = start + (end-start)/2;
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid] < target){
                start = mid;
            }else{
                end = mid;
            }
        }
        if(nums[start] == target) return start;
        if(nums[end] == target) return end;
        return -1;
    }

在这个模板里需要注意的有:

• 循环条件是while(start +1 < end) 也就是说相邻即退出，退出时有start和end两个量；
• 计算mid时用先减再除的方法可以避免数据溢出；
• 判断中间量和边界量时，可以把三个情况都列出来，因为有时候是<=合并有时候是>=合并；
• 最后要double check，才可以返回；

递归的模板

    int search(vector<int>& nums, int left, int right, int target) {
        if(left > right) return -1;
        int mid = start + (end-start)/2;
        if(nums[mid] == target)
        	return mid;
        else if(nums[mid] > target){
       	 	right = mid - 1;
       	 	return seach(nums, left, right, target);
       	 }else{
       	 	left = mid + 1;
       	 	return search(nums, left, right, target);
       	 }        	
    }

常见题目

给出目标在升序数组中的开始位置和结束位置

这个问题可以拆为两个
开始位置，即第一次由小于target变为等于target的问题，xxxoo

    int findFirst(vector<int>& nums, int target){
        int start = 0, end = nums.size()-1;
        //相邻就退出
        while(start+1 < end){
            int mid = start + ( end - start ) / 2;
            if(nums[mid] == target){
                end = mid;
            }else if(nums[mid] < target){
                start = mid;
            }else{
                end = mid;
            }
        }
        //double check
        if(nums[start] == target) return start;
        if(nums[end] == target)  return end;
        return -1;
    }

结束位置，即第一次由等于target变为大于target的问题，oooxx

    int findLast(vector<int>& nums, int target){
        int start = 0, end = nums.size()-1;
        //相邻就退出
        while(start+1 < end){
            int mid = start + ( end - start ) / 2;
            if(nums[mid] == target){
                //第一个不一样
                start = mid;
            }else if(nums[mid] < target){
                start = mid;
            }else{
                end = mid;
            }
        }
        //double check
        //第二个不一样
        if(nums[end] == target)  return end;
        if(nums[start] == target) return start;   
        return -1;
    }

可以看到只有两处不同，一个是<=还是>=的合并，一个是返回end还是start

badVersion

判断第一个出错的版本，即oooxxxxxx

    int firstBadVersion(int n) {
        int start = 1, end = n;
        while(start < end){
            int mid = start + (end-start)/2;
            if(isBadVersion(mid)){
                end = mid;
            }else{
                start = mid+1;
            }
        }
        if(isBadVersion(start))  return start;
        return end;
    }

找峰值peak

即大于左右的元素
可以分为三种情况:

• mid < mid + 1 即处于升序，那么右边肯定有峰值 left=mid
• mid < mid - 1 处于降序，左边肯定有峰值 end = mid
• mid > mid + 1 && mid > mid -1 本身就是峰值

        int start = 0, end = nums.size()-1;
        while(start+1 < end){
            int mid = start + (end-start)/2;
            if(nums[mid] < nums[mid+1]){
                start = mid;
            }else if(nums[mid] < nums[mid-1]){
                end = mid;
            }else{
                return mid;
            }
        }
        return nums[start]<nums[end]?end:start;

旋转有序数组

这个有好几个题目，旋转有序数组举例[4,5,8,2,3]
即从中间分开，左边是一个上升数组，右边同样是一个上升数组

寻找旋转有序数组的最小值

啊这个题做了很久，需要考虑的情况比较多，与通用的二分法不一样
其实不用二分更简单，如果一定要用二分的话:
首先需要考虑如果没有旋转，那么就得返回第一个值
还有!!就是如果有多个重复的，那么是在左区间找还是右区间找是不确定的
所以可以让right-- 来缩短

        int start = 0, end = numbers.size() - 1;
        if(numbers.size() == 1 || numbers[start]<numbers[end])
            return numbers[start];
        while(start  < end){
            int mid = start + (end-start)/2;
            if(numbers[mid] > numbers[end]){
                start = mid+1;
            }else if(numbers[mid] < numbers[end]){
                end = mid;
            }else{
                end --;
            }
        }
        return numbers[start];

搜索旋转数组

假设没有重复数字

    public int search(int[] A, int target) {
        // write your code here
        if(A.length == 0) return -1;
        int start = 0, end = A.length - 1;
        while(start + 1 < end){
            int mid = start + (end - start) / 2;
            if(A[mid] == target){
                return mid;
            }
            if(A[start] <= A[mid]){
                if(A[start]<=target && target <= A[mid]){
                end = mid;
            }else{
                start = mid;
            }
            }else{
                 if(A[mid]<=target && target<=A[end]){
                start = mid;
            }else{
                end = mid;
            }
            }
           
        }
        if(A[start] == target) return start;
        if(A[end] == target) return end;
        return -1;
    }

如果有重复数字

    bool search(vector<int> &A, int target) {
        // write your code here
        if(A.size() == 0) return false;
        //find the pivot
        int left = 0, right = A.size() - 1;
        while(left < right){
            int mid = left + (right - left) / 2;
            if(A[mid] > A[right]){
                left = mid + 1;
            }else if(A[mid] < A[right]){
                right = mid;
            }else{
                if(right > 0 && A[right-1] > A[right]){
                    left = right;
                }
                else{
                    right -= 1;
                }
            }
        }
        int pivot = left;
        
        //split into two 
        if(pivot == 0){
            left = 0;
            right = A.size() - 1;
        }else if(target >= A[0]){
            left = 0;
            right = pivot - 1;
        }else{
            left = pivot;
            right = A.size() - 1;
        }
        
        //search and find the target
        while(left < right){
            int mid = left + (right - left) / 2;
            if(A[mid] == target) return true;
            if(A[mid] < target) left = mid + 1;
            if(A[mid] > target) right = mid;
        }
        if(A[left] == target || A[right]==target) return true;
        return false;
    }