leetcode笔记|二分法

基本思路：可以不用递归！！用迭代写！！

迭代遍历：while循环里，更新begin,end，middle和target比较，临界条件是begin>end 

 

例1 找左右范围

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

-->找最右等于target（左边界）和最左等于target（右边界）

-->找最右等于target（左边界）和最左大于target-1（右边界）

（如果最右没有等于，就取>，此时左边界和右边界相等且不为target，说明无值）

（理解：首先注意临界条件是begin>end，不是middle==target，意味着收敛到target时能遍历到其左右若干个连续值，计算左边界时，为了让这些连续值包含所有的target的左边，>=时就往左边走；计算有边界时，为了让这些连续值包含所有的target的右边，<=时就往右边走）

/** * 范围查询规律 * 初始化: * int left = 0; * int right = nums.length - 1; * 循环条件 * left <= right * 右边取值 * right = mid - 1 * 左边取值 * left = mid + 1 * 查询条件 * >= target值, 则 nums[mid] >= target时, 都减right = mid - 1 * > target值, 则 nums[mid] > target时, 都减right = mid - 1 * <= target值, 则 nums[mid] <= target时, 都加left = mid + 1 * < target值, 则 nums[mid] < target时, 都加left = mid + 1 * 结果 * 求大于(含等于), 返回left * 求小于(含等于), 返回right * 核心思想: 要找某个值, 则查找时遇到该值时, 当前指针(例如right指针)要错过它, 让另外一个指针(left指针)跨过他(体现在left <= right中的=号), 则找到了 */

 

class Solution { 
public:
    int binarySearch(vector<int>& nums, int target, bool lower) {
        int left = 0, right = (int)nums.size() - 1, ans = (int)nums.size();
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] > target || (lower && nums[mid] >= target)) {
                right = mid - 1;
                ans = mid;
            } else {
                left = mid + 1;
            }
        }
        return ans;
    }

    vector<int> searchRange(vector<int>& nums, int target) {
        int leftIdx = binarySearch(nums, target, true);
        int rightIdx = binarySearch(nums, target, false) - 1;
        if (leftIdx <= rightIdx && rightIdx < nums.size() && nums[leftIdx] == target && nums[rightIdx] == target) {
            return vector<int>{leftIdx, rightIdx};
        } 
        return vector<int>{-1, -1};
    }
};

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int l=0,r=nums.size()-1;
        while(l<=r){
            int m=l+(r-l)/2;
            if(nums[m]==target){
                int begin=m,end=m;
                while(begin>0&&nums[begin-1]==target)--begin;
                while(end<nums.size()-1&&nums[end+1]==target)++end;
                return {begin,end};
            }
            target>nums[m]?l=m+1:r=m-1;
        }
        return {-1,-1};
    }
};

 /**
     * 二分查找
     */
    public int[] searchRange(int[] nums, int target) {
        //寻找左边界(这里寻找第一个 >= target的索引)
        int leftIndex = search(nums, target);
        if (leftIndex >= nums.length || nums[leftIndex] != target){
            return new int[]{-1, -1};
        }
        //寻找右边界(这里寻找第一个 >= target+1的索引)
        int rightIndex = search(nums, target + 1);
        return new int[]{leftIndex, rightIndex - 1};
    }

    /**
     * 寻找第一个>=目标值的索引, 找不到则返回数组长度
     */
    private int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        while (left <= right){
            int mid = (right - left) / 2 + left;
            if (nums[mid] >= target){
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }

例2 旋转数组

例3 矩阵

编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：

• 每行中的整数从左到右按升序排列。

• 每行的第一个整数大于前一行的最后一个整数。

正常解法：

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int begin=0;
        int end=matrix.size()-1;
        int middle=0;
        if(matrix[begin][0]>target)return false;
        while(begin<=end){
            middle=(begin+end)/2;
            int m=matrix[middle].size();
            if(matrix[middle][0]==target||matrix[middle][m-1]==target)return true;
            if(matrix[middle][0]>target)end=middle-1;
            else{
               // if(matrix[middle][m-1]==target)return true;
                if(matrix[middle][m-1]>target)break;
                else begin=middle+1;
            }
    }
        int row=middle;
        begin=1;
        end=matrix[row].size()-2;
        while(begin<=end){
            middle=(begin+end)/2;
            if(matrix[row][middle]==target)return true;
            if(matrix[row][middle]>target)end=middle-1;
            else begin=middle+1;
        }
        return false;
    }
};

 

二分法，可以把二维矩阵向左旋转45度，看成一个二叉树

（666）

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int m = matrix.length, n = matrix[0].length;
        int a = 0,b=n-1;
        while(a>=0&&a<m&&b>=0&&b<n){
            if(matrix[a][b]==target) return true;
            if(matrix[a][b]>target) b--;
            else a++;
        }
        return false;
    }
}

 

例4 峰值

峰值元素是指其值严格大于左右相邻值的元素。

给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。

你可以假设 nums[-1] = nums[n] = -∞ 。

你必须实现时间复杂度为 O(log n) 的算法来解决此问题。

 以下解法会超时！

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        int n=nums.size();
        int begin=0;
        int end=n-1;
        int middle=0;
        if(n==1)return 0;
        if(n==2)return nums[0]>nums[1]?0:1;
        while(begin<=end){
            middle=(begin+end)/2;
            if(middle>0&&nums[middle]>nums[middle-1]&&middle<n-1&&nums[middle]>nums[middle+1])
                return middle;
            if(middle>0&&nums[middle]<nums[middle-1])end=middle-1;
            if(middle<n-1&&nums[middle]<nums[middle+1])begin=middle+1;
        }return middle;
    }
};

需要减少判断语句

class Solution {
public:
    int getval(int index,vector<int>& nums){
        int n=nums.size();
        if(index<0)return(nums[0]-1);
        if(index>=n)return(nums[n-1]-1);
        else return nums[index]; 
    }
    int findPeakElement(vector<int>& nums) {
        int n=nums.size();
        int begin=0;
        int end=n-1;
        int middle=0;
        if(n==1)return 0;
        if(n==2)return nums[0]>nums[1]?0:1;
        while(begin<=end){
            middle=(begin+end)/2;
            if(getval(middle,nums)>getval(middle-1,nums)&&getval(middle,nums)>getval(middle+1,nums))
                return middle;
            if(getval(middle,nums)<getval(middle-1,nums))end=middle-1;
            else begin=middle+1;
        }return middle;
    }
};

法2：

class Solution {
    public int findPeakElement(int[] nums) {
        int l = 0, r = nums.length - 1;
        while (l < r) {
            int mid = l + ((r - l) >> 1);
            if (nums[mid] < nums[mid+1]) {
                l = mid + 1;
            } else {
                r = mid;
            }
        }
        return l;
    }
}