二分查找

LC33

package com.wang.leetcode.BinarySearch;
//搜索旋转排序数组
class Solution33{
    public int search(int[] nums, int target){
        int left=0,right= nums.length-1;
        while (left<=right){
            int mid=left+(right-left)/2;
            //相等
            if (nums[mid]==target){
                return mid;
            }


            if (nums[mid]>=nums[left]){
                if (target>=nums[left]&&target<nums[mid]){
                    right=mid-1;//右边界缩小
                }else left=mid+1;
            }


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

        }
        return -1;
    }
}
public class LC33 {
    public static void main(String[] args) {
       Solution33 solution33=new Solution33();
        int[]nums={4,5,6,7,0,1,2};
        int target=0;
        System.out.println(solution33.search(nums,target));
    }
}

LC704

package com.wang.leetcode.BinarySearch;
//二分查找
//给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
class Solution704{
    public int search(int[] nums, int target){
        int left=0,right= nums.length-1;
        while (left<=right){
            int mid=left+(right-left)/2;
            if (nums[mid]==target)return mid;
            else if (nums[mid]<target)left=mid+1;
            else right=mid-1;
        }
        return -1;
    }
}
public class LC704 {
    public static void main(String[] args) {
        Solution704 solution704=new Solution704();
        int[]nums={-1,0,3,5,9,12};
        int target=2;
        System.out.println(solution704.search(nums,target));

    }
}

LC34

package com.wang.leetcode.BinarySearch;

import java.util.Arrays;

//在排序数组中查找元素的第一个和最后一个位置
//给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。
//如果数组中不存在目标值 target，返回 [-1, -1]。
class Solution34{
    public int[] searchRange(int[] nums, int target){
        return new int[]{left_bound(nums, target), right_bound(nums, target)};
    }

    //找左右边界，目的不是nums[mid]==target了，目的是左右边界的值==target
    int left_bound(int[] nums, int target){
        int left=0,right=nums.length-1;
        while (left<=right){
            int mid = left + (right - left) / 2;
            if (nums[mid]<target)left=mid+1;
            else if (nums[mid] > target) right=mid-1;
            else right=mid-1;
        }
        if (left<0||left>=nums.length)return -1;
        return nums[left]==target?left:-1;
    }
    int right_bound(int[] nums, int target){
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] < target) {
                left = mid + 1;
            } else if (nums[mid] > target) {
                right = mid - 1;
            } else if (nums[mid] == target) {
                // 这里改成收缩左侧边界即可
                left = mid + 1;
            }
        }
        // 最后改成返回 right
        if (right < 0 || right >= nums.length) {
            return -1;
        }
        return nums[right] == target ? right : -1;
    }
}
public class LC34 {
    public static void main(String[] args) {
        Solution34 solution34=new Solution34();
        int[]nums={5,7,7,8,8,10};
        int tar=5;
        System.out.println(Arrays.toString(solution34.searchRange(nums,tar)));
    }
}

LC240

package com.wang.leetcode.BinarySearch;
//搜索二维矩阵 II
//编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：
//每行的元素从左到右升序排列。
//每列的元素从上到下升序排列。
class Solution240{
    public boolean searchMatrix(int[][] matrix, int target){
        int m = matrix.length, n = matrix[0].length;
        // 初始化在右上角
        int i = 0, j = n - 1;
        while (i<m&&j>=0){
            if (matrix[i][j]==target)return true ;
            else if (matrix[i][j]>target)j--;
            else i++;
        }
        return false;
    }
}
public class LC240 {
    public static void main(String[] args) {
        Solution240 solution240=new Solution240();
        int[][] matrix={{1,4,7,11,15},{2,5,8,12,19},{3,6,9,16,22},{10,13,14,17,24},{18,21,23,26,30}};
        int tar=5;
        System.out.println(solution240.searchMatrix(matrix,tar));
    }
}

LC153

package com.wang.leetcode.BinarySearch;
//寻找旋转排序数组中的最小值
//已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组
//数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。
//找出并返回数组中的 最小元素
class Solution153{
    public int findMin(int[] nums){
        int left=0,right=nums.length-1;
        while (left<right){//是<,因为要left 和 right 收敛到同一个位置，即最小值所在的位置
            int mid=left+(right-left)/2;
            if (nums[mid]<nums[right])right=mid-1;
            else left=mid+1;
        }
        return nums[left];
    }
}
public class LC153 {
    public static void main(String[] args) {
        Solution153 solution153=new Solution153();
        int[] nums={4,5,6,7,0,1,2};
        System.out.println(solution153.findMin(nums));
    }
}