leetcode 153 寻找旋转排序数组中的最小值

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次旋转后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：

若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
若旋转 4 次，则可以得到 [0,1,2,4,5,6,7]

注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。

给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

示例 1：

输入：nums = [3,4,5,1,2]
输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。

示例 2：

输入：nums = [4,5,6,7,0,1,2]
输出：0
解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。

示例 3：

输入：nums = [11,13,15,17]
输出：11
解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。

提示：

n == nums.length
1 <= n <= 5000
-5000 <= nums[i] <= 5000
nums 中的所有整数 互不相同
nums 原来是一个升序排序的数组，并进行了 1 至 n 次旋转

package com.example.lettcode.dailyexercises;

/**
 * @Class FindMin
 * @Description 153 寻找旋转排序数组中的最小值
 * @Author
 * @Date 2021/4/8
 **/
public class FindMin {
    /**
     * 二分法
     *
     * @param nums
     * @return
     */
    public static int findMin(int[] nums) {
        if (nums.length == 0) return nums[0];
        int start = 0;
        int end = nums.length - 1;
        int mid = 0;
        while (start <= end) {
            mid = (start + end) >> 1;
            if (nums[mid] == nums[end]) {
                end--; continue;// 该判断是表示可能存在重复值的情况，本题可不用判断
            }
            // 最小值在前半部分
            else if (nums[mid] < nums[end]) {
                // 最小值可能在[start,mid],mid可能是最小值
                end = mid;
            } else {// 最小值在后半部分(mid, end],mid 不可能是最小值
                start = mid + 1;
            }
        }
        return nums[start];
    }
}

// 测试用例 
public static void main(String[] args) {
	int[] nums = new int[]{3, 4, 5, 1, 2};
	int ans = FindMin.findMin(nums);
	System.out.println("FindMin demo01 result : " + ans);

	nums = new int[]{4, 5, 6, 7, 0, 1, 2};
	ans = FindMin.findMin(nums);
	System.out.println("FindMin demo02 result : " + ans);

	nums = new int[]{11, 13, 15, 17};
	ans = FindMin.findMin(nums);
	System.out.println("FindMin demo03 result : " + ans);

	nums = new int[]{1};
	ans = FindMin.findMin(nums);
	System.out.println("FindMin demo04 result : " + ans);

	nums = new int[]{3, 1, 2};
	ans = FindMin.findMin(nums);
	System.out.println("FindMin demo05 result : " + ans);
}

二分查找

package com.example.lettcode.search;

/**
 * @Class BinarySearch
 * @Description 二分查找
 * 查找有序数组中是否存在某元素，若存在返回所在位置，不存在则返回-1
 * @Author
 * @Date 2021/4/8
 **/
public class BinarySearch {
    /**
     * 二分查找
     * （1）while循环
     */
    public static int binarySearch1(int[] nums, int target) {
        if (nums == null || nums.length == 0) return -1;
        int low = 0;
        int high = nums.length - 1;
        while (low <= high) {
            int mid = (low + high) >> 1;
            if (nums[mid] == target) return mid;
            if (nums[mid] > target) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return -1;
    }

    /**
     * 二分查找
     * （2）递归方式
     */
    public static int binarySearch(int[] nums, int target) {
        if (nums == null || nums.length == 0) return -1;
        return recur(nums, 0, nums.length - 1, target);
    }

    private static int recur(int[] nums, int start, int end, int target) {
        if (nums == null || nums.length == 0) return -1;
        if (start > end) return -1;
        int mid = (start + end) >> 1;
        if (nums[mid] == target) return mid;
        if (nums[mid] > target) return recur(nums, start, mid - 1, target);
        if (nums[mid] < target) return recur(nums, mid + 1, end, target);
        return -1;
    }

    public static void main(String[] args) {
        int[] nums = new int[]{1, 2, 3, 4, 5, 6, 8, 9, 15, 45, 85, 86};
        int target = 8;
        int ans = binarySearch(nums, target);
        System.out.println("BinarySearch demo01 result : " + ans);
    }
}