33搜索旋转排序数组-hot100-Java题解

一、问题描述：

33搜索旋转排序数组
整数数组 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 。
你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
示例 1：    输入：nums = [4,5,6,7,0,1,2], target = 0    输出：4
示例 2：    输入：nums = [4,5,6,7,0,1,2], target = 3    输出：-1
示例 3：    输入：nums = [1], target = 0   输出：-1
提示：  1 <= nums.length <= 5000   -104 <= nums[i] <= 104   nums 中的每个值都 独一无二
题目数据保证 nums 在预先未知的某个下标上进行了旋转    -104 <= target <= 104

二、题解：

题解1：

根本不管题目限制，直接强上：

public class Solution {
    public int search(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            if (nums[i]== target) return i;
        }
        return -1;
    }
}

本地测试：

@Test
public void testSolution(){
    int[][] arr = {
            {4,5,6,7,0,1,2},
            {4,5,6,7,0,1,2},
            {1},
    };

    int[] targets = {
            0,
            3,
            -1

    };

    for (int i = 0; i < targets.length; i++) {
        System.out.println(Arrays.toString(arr[i]) + " ,target is " + targets[i]
                + "` result is " + search(arr[i],targets[i]) );
    }
}

本地模拟acm模式：

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    String[] s = scanner.nextLine().split(",");
    int target = Integer.parseInt(scanner.nextLine());
    int[] nums = new int[s.length];
    for (int i = 0; i < s.length; i++) nums[i] = Integer.parseInt(s[i]);
    Solution solution = new Solution();
    int search = solution.search(nums, target);
    System.out.println(search);
}

时间复杂度O(n)

题解2：

应该是这样的思路，因为这个nums是已经被翻转过了，也就是说被分成2段有序的数组了，那么搜索的位置可以不同。

class Solution {
    public int search(int[] nums, int target) {
        if (target < nums[0]){
            if (target > nums[nums.length - 1]) {
                return -1;
            }else if (target == nums[nums.length - 1]){
                return nums.length - 1;
            }
            for (int i = nums.length - 2; i >= 0 && nums[i] < nums[i + 1]; i--) {
                if (target == nums[i]) return i;
            }
            return -1;
        }

        if (target == nums[0]) return 0;
        for (int i = 1; i < nums.length && nums[i] > nums[i - 1]; i++) {
            if (target == nums[i]) return i;
        }
        return -1;
    }
}

时间复杂度O(logn)