【LeetCode】解题33：Search in Rotated Sorted Array

关注

原创最新推荐文章于 2022-02-21 15:00:35 发布 251 阅读 AI 写同款· GEO 优化 ›

虚拟化Esxi 和华为交换机--配置链路捆绑在这种模式下，Eth-Trunk的建立和成员接口的加入都需要手工配置，没有LACP协议的参与。● 在没有配置802.3ad聚合时，启用基于IP哈希的路由将中断网络，因此必须先对虚拟交换机进行更改。再去修改交换机的链路聚合模式（交换机配置为手动模式的链路聚合）当服务器需要通过交换机从远端服务器获取配置文件后才可以启动链路聚合时，交换机的链路聚合口需要配置lacp force-forward。● 交换机必须设置手动模式的链路聚合，虚拟交换机的负载平衡方法必须设置为基于IP哈希的路由。阅读详情

LeetCode解题 33：Search in Rotated Sorted Array

Problem 33: Search in Rotated Sorted Array [Medium]
解题思路
Solution (Java)
修改过程

Problem 33: Search in Rotated Sorted Array [Medium]

Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]).

You are given a target value to search. If found in the array return its index, otherwise return -1.

You may assume no duplicate exists in the array.

Your algorithm’s runtime complexity must be in the order of O(log n).

Example 1:

Input: nums = [4,5,6,7,0,1,2], target = 0
Output: 4

Example 2:

Input: nums = [4,5,6,7,0,1,2], target = 3
Output: -1

来源：LeetCode

解题思路

基本思路是利用二分查找，每层递归排除掉一半的数值。
难点在于条件判断，需要考虑要查找的target会不会因为排序数组的旋转而不在原本二分查找的那半段范围。为了方便说明，将头尾相接处称为断崖，二分点下标称为p，以下为需要分类讨论的情况：
a. 假设nums[p] < target，说明目标值较大，正常情况下需要查找数组的右半部分，此时应有nums[right] > target，需要查找p+1 ~ right-1；
b. 当nums[right] < target时，与正常情况不同，是需要讨论的重点。按断崖所在的位置进行分类讨论。
b1. 寻找断崖所处位置的方法是比较nums[right]与nums[p]的值，如果nums[right] < nums[p]，则说明断崖在p ~ right之间，即最大的尾部处于这之间，要找的目标值比nums[p]大，就可以在p+1 ~ right-1之间查找。（例如在[4,5,6,7,8,9,1,2,3]中寻找9的第一次二分查找。）
b2. 如果nums[right] > nums[p]，则说明p ~ right之间是严格升序的，断崖应该在left ~ p之间，因此既比nums[p]大又比nums[right]大的目标值就应该在left ~ p-1之间查找。（例如在[7,8,9,1,2,3,4,5,6]中寻找9的第一次二分查找。）
c. 上述数值比较过程中如果有正好相等的情况则之间返回下标即可。如果有left > right的情况则说明查找失败，返回-1。
数组个数为0或仅剩1个数且不为target时直接返回-1。

二分查找时间复杂度O(log n)。

要点：二分查找、条件判断

Solution (Java)

class Solution {
    public int search(int[] nums, int target) {
        int N = nums.length;
        if(N == 0) return -1;
        return partSearch(nums, 0, N-1, target);
    }
    private int partSearch(int[] nums, int left, int right, int target){
        if(left > right) return -1;
        if(left == right && nums[left] != target) return -1;
        int len = right - left + 1;
        int p = left + len/2;
        if(nums[p] == target){
            return p;
        }
        else if(nums[p] < target){
            if(nums[right] == target){
                return right;
            }
            else if(nums[right] > target){
                return partSearch(nums, p+1, right-1, target);
            }
            else{
                if(nums[right] < nums[p]){
                	// 断崖在p~right之间
                    return partSearch(nums, p+1, right-1, target);
                }
                else{
                	// 断崖在另半部分
                    return partSearch(nums, left, p-1, target);
                }
            }
        }
        else{
            if(nums[left] == target){
                return left;
            }
            else if(nums[left] < target){
                return partSearch(nums, left+1, p-1, target);
            }
            else{
                if(nums[left] > nums[p]){
                	// 断崖在left~p之间
                    return partSearch(nums, left+1, p-1, target);
                }
                else{
                	// 断崖在另半部分
                    return partSearch(nums, p+1, right, target);
                }
            }
        }
    }
}