leetcode(八)---二分查找

---

前言

二分查找

一、搜索旋转排序数组

整数数组 nums 按升序排列，数组中的值 互不相同 。
在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

class Solution {
    public int search(int[] nums, int target) {
        int n = nums.length-1;
        int left=0;
        int right=n;

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

            else{
                if(nums[mid]<target&&target=<nums[right]){
                    left=mid+1;

                }else{
                    right=mid-1;
                }
            }
        }
        return -1;
       
      
    }
}

二、在排序数组中查找元素的第一个和最后一个位置

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。

进阶：

你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗？

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int leftborder=leftBorder(nums,target);
        int rightborder=rightBorder(nums,target);
        if(leftborder==-2||rightborder==-2){
            return new int[]{-1,-1};
        }
        if(rightborder-leftborder>1){
            return new int[]{leftborder+1,rightborder-1};
        }
        return new int[]{-1,-1};
    

    }
    public int leftBorder(int[] nums, int target){
        int n=nums.length-1;
        int left =0;
        int right =n;
        int border =-2;
        while(left<=right){
            int mid = (left+right)/2;

            if(nums[mid]<target){
                left=mid+1;

            }else{
                right=mid-1;
                border=right;

            }
        }
        return border;
    }
      public int rightBorder(int[] nums, int target){
        int n=nums.length-1;
        int left =0;
        int right =n;
        int border =-2;
        while(left<=right){
            int mid = (left+right)/2;

            if(nums[mid]<=target){
                left=mid+1;
                border=left;

            }else{
                right=mid-1;
                

            }
        }
        return border;
    }
}

三、x的平方根

实现 int sqrt(int x) 函数。
计算并返回 x 的平方根，其中 x 是非负整数。
由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

class Solution {
    public int mySqrt(int x) {
        if(x==0){
            return 0;
        }
        int left=0;
        int right=x;
        int ans=0;
        while (left<=right){
            int mid=(left+right)/2;
            if((long)mid*mid<=x){
                left=mid+1;
                ans=mid;
            }else {
                right=mid-1;
            }
        }
        return ans;

    }
}

四、寻找峰值

峰值元素是指其值大于左右相邻值的元素。
给你一个输入数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。
你可以假设 nums[-1] = nums[n] = -∞ 。

class Solution {
    public int findPeakElement(int[] nums){
       int left=0;
       int right=nums.length-1;
       int index=0;
       while (left<right){
           int mid=(left+right)/2;
           if(nums[mid]>nums[mid+1]){
               right=mid;
           }else{
               left=mid+1;
               index=left;
           }
       }
       return index;

    }
}

五、搜索二维矩阵II

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：
每行的元素从左到右升序排列。
每列的元素从上到下升序排列。

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



        }
        return false;

    }
}

六、寻找重复数

给定一个包含 n + 1 个整数的数组 nums ，其数字都在 1 到 n 之间（包括 1 和 n），可知至少存在一个重复的整数。

假设 nums 只有 一个重复的整数 ，找出 这个重复的数 。

你设计的解决方案必须不修改数组 nums 且只用常量级 O(1) 的额外空间。

class Solution {
    public int findDuplicate(int[] nums){
        int l=0;
        int r=nums.length;
        int cnt=0;
        while (l<r){
            int mid=(l+r)/2;
            for(int i=0;i<nums.length;i++){
                if(nums[i]<mid){
                    cnt++;
                }
            }
            if(cnt>mid){
                r=mid;
            }else {
                l=mid+1;
            }

        }
        return r;
    }
}

七、最长递增子序列

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

class Solution {
    public int lengthOfLIS(int[] nums){
         if(nums==null||nums.length==0){
            return 0;
        }
      int[] dp = new int[nums.length];
      Arrays.fill(dp,1);
      int max=0;
      for(int i =0;i<nums.length;i++){
          for(int j=0;j<i;j++){
              if(nums[i]>nums[j])
              dp[i]=Math.max(dp[i],dp[j]+1);
              max=Math.max(dp[i],max);
          }
      }
      return max;

    }
}

九、两个数组的交集II

给定两个数组，编写一个函数来计算它们的交集。

class Solution {
    public int[] intersect(int[] nums1, int[] nums2){
        int m=nums1.length;
        int n=nums2.length;
        if(m>n){
            return intersect(nums2,nums1);
        }
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int i=0;i<m;i++){
            if(map.containsKey(nums1[i])){
                map.put(nums1[i],map.get(nums1[i])+1);
            }else{
                map.put(nums1[i],1);
            }
        }
          int[] ans=new int[n];
           int i =0;
           for(int num:nums2){
               if(map.containsKey(num)&&map.get(num)>0){
                   ans[i]=num;
                   i++;
                   
                   map.put(num,map.get(num)-1);
                }
               
           }
        return Arrays.copyOfRange(ans,0,i);

   


    }
}

十、两个数组的交集II

给你一个 n x n 矩阵 matrix ，其中每行和每列元素均按升序排序，找到矩阵中第 k 小的元素。
请注意，它是 排序后 的第 k 小元素，而不是第 k 个 不同 的元素。

class Solution {
    public int kthSmallest(int[][] matrix, int k) {
        int m =matrix.length;
        int n = matrix.length;
        int[] tmp =new int[m*n];
        int i =0;
        for(int[] row:matrix){
            for (int num:row){
                tmp[i++]=num;

            }
        }
        Arrays.sort(tmp);
        return tmp[k-1];


    
    }
}