力扣刷题-----基础篇--二分查找

1、二分查找

class Solution {
    public int[] searchRange(int[] nums, int target) {
        // 利用两个二分查找，第一个找左边界，第二个找右边界
        int[] res = new int[2];
        if (nums.length == 0)return new int[]{-1,-1};

        res[0] = bs1(nums,target);
        res[1] = binarySearch2(nums,target);

        return res;
    }

    // 找左边界
    private int bs1(int[] nums,int target){
        int l =-1;
        int r = nums.length-1;
        while(l+1<r){
            int m =(l+r)/2;
            if(nums[m]<target) l=m;
            else {r=m;}
        }
        if (nums[r]==target) return r;
        return -1;
    }

  

    // 找右边界
    private int binarySearch2(int[] nums,int target){
        int l =0;
        int r=nums.length;
        while(l+1 <r){
            int m=(l+r)/2;
            //此处必须是小于等于
            if(nums[m]<=target){l=m;}
            else{r=m;}
        }


        if (nums[l]==target) return l;
        return -1;
        
    }

}

 

 // 1. 首先明白，旋转数组后，从中间划分，一定有一边是有序的。
        // 2. 由于一定有一边是有序的，所以根据有序的两个边界值来判断目标值在有序一边还是无序一边
        // 3. 这题找目标值，遇到目标值即返回
        // 4. 注意：由于有序的一边的边界值可能等于目标值，所以判断目标值是否在有序的那边时应该加个等号(在二分查找某个具体值得时候如果把握不好边界值，可以再每次查找前判断下边界值，也就是while循环里面的两个if注释)



class Solution {
    public int search(int[] nums, int target) {

        int len = nums.length;
        if(len == 0) return -1;
        int l = 0, r = len - 1;

        while(l<=r){
            int mid = (l+r)/2;
            if(nums[mid] == target) return mid;

            if(nums[mid] <nums[r]){
                
               if(nums[mid]<target && target <=nums[r])
                {l=mid+1;
                }else{r=mid-1;}

            }
            else{
                if(target<nums[mid] && target>=nums[l]){
                    r=mid-1;
                }else{l=mid+1;}

            }
            
        }
 return -1;
    }
}

 

 

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

    }

    //找出在哪一行
    private int cal(int[][] matrix, int target){
        int res =0;
        int m = matrix.length-1;
        int n =matrix[0].length-1;
        int bin = 0;
        int end = m;

        while(bin <= end){
            int mid = (bin+end)/2;
            if(target>=matrix[mid][0] && target<=matrix[mid][n]){return mid;}
            else if(target<matrix[mid][0]){end =mid-1;}
            else{bin=mid+1;}
        }

        return -1;
    }


}

class Solution {
    public int findMin(int[] nums) {
        int l =-1;
        int r= nums.length-1;
        if(nums[l]<nums[r]){return 0;}

        while(l<r){
            int m =(l+r)/2;
           

            if(nums[m]>nums[l] && nums[m]>nums[r]){l=m+1;}
            else {r=m;}
        }
        return nums[l];

    }
}

 

 

class Solution {
    public int findPeakElement(int[] nums) {

    }
}