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


    已知一个长度为 n 的数组,预先按照升序排列,经由 1n旋转 后,得到输入数组。例如,原数组 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 原来是一个升序排序的数组,并进行了 1n 次旋转
    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);
        }
    }
    
  • 相关阅读:
    感知器算法--python实现
    PHP appserv + ZendStudio12.5.1 + 注册码
    第九周-每周例行报告
    第八周-每周例行报告
    感谢THUNDER
    第七周-每周例行报告
    第六周-每周例行报告
    第五周-每周例行报告
    第四周-四则运算试题生成
    第四周-单元测试
  • 原文地址:https://www.cnblogs.com/fyusac/p/14631037.html
Copyright © 2020-2023  润新知