Leetcode 33.搜索旋转排序数组

这道题自己调试搞了好几个小时。

代码入下：

public static int search(int[] nums, int target) {
        if (nums.length == 0) {
            return -1;
        }
        if (nums.length == 1) {
            return nums[0] == target ? 0 : -1;
        }
        int index = 1;
        int left = 0;
        while (left < index && index < nums.length) {
            //两个指针都在前半段
            if (nums[left] <= nums[index] && nums[index] > nums[0]) {
                if (target >= nums[0]) {  //target在前半段
                    if (target == nums[left]) {
                        return left;
                    }
                    if (target == nums[index]) {
                        return index;
                    }
                    if (target < nums[index]) {
                        int mid = (index + left) / 2 > 0 ? (index + left) / 2 : 1;
                        if (mid == index || mid == left) {
                            break;
                        }
                        if (nums[mid] > target) {
                            index = mid;
                            continue;
                        }
                        if (nums[mid] == target) {
                            return mid;
                        }
                        if (nums[mid] < target) {
                            left = mid;
                            continue;
                        }
                    }
                    if (target > nums[index]) {
                        left = index;
                        int step = (nums.length - 1 - index) / 2 > 0 ? (nums.length - 1 - index) / 2 : 1;
                        index = step + index;
                        continue;
                    }
                } else {  //target在后半段
                    left = index;
                    int step = (nums.length - 1 - index) / 2 > 0 ? (nums.length - 1 - index) / 2 : 1;
                    index = Math.min(step + index, nums.length - 1);
                    continue;
                }
            }
            //两个指针横跨前后两段
            if (nums[left] > nums[index]) {
                if (target >= nums[0]) {  //target在前半段
                    if (target == nums[left]) {
                        return left;
                    }
                    if (target > nums[left]) {
                        index = left + (index - left) / 2;
                        continue;
                    }
                } else { //target在后半段
                    if (target == nums[index]) {
                        return index;
                    }
                    if (target < nums[index]) {  //
                        int mid = (index + left) / 2 > 0 ? (index + left) / 2 : 1;
                        if (mid == index || mid == left) {
                            break;
                        }
                        if (nums[mid] < nums[0]) { //mid也在后半段
                            if (nums[mid] > target) {
                                index = mid;
                                continue;
                            }
                            if (nums[mid] == target) {
                                return mid;
                            }
                            if (nums[mid] < target) {
                                left = mid;
                                continue;
                            }
                        } else { //mid在前半段
                            left = mid;
                            continue;
                        }
                    }
                    if(target>nums[index]){
                        left=index;
                        int step = (nums.length - 1 - index) / 2 > 0 ? (nums.length - 1 - index) / 2 : 1;
                        index = Math.min(step + index, nums.length - 1);
                        continue;
                    }
                }
            }
            //两个指针在后半段，  这个时候target只有可能在后半段，所以不比做额外的判断
            if (nums[left] <= nums[index] && nums[left] < nums[0]) {
                if (target == nums[left]) {
                    return left;
                }
                if (target == nums[index]) {
                    return index;
                }
                if (target > nums[index]) {
                    left = index;
                    index = (nums.length - index) / 2 + index;
                    continue;
                }
                if (target < nums[index]) {
                    if (index == nums.length - 1) {
                        return -1;
                    }
                    index = left + (index - left) / 2;
                }
            }
        }
        return -1;
    }