旋转数组的二分查找

旋转数组的二分查找

可参考Leetcode 33、81题

1. 何为旋转数组

讲一个有序数组从任意位置隔断分为两部分，两部分调换位置，调换位置之后的数组即为旋转数组

2. 如何对旋转数组进行二分查找（假定数组中不含重复元素）

重点：对于旋转数组来说，无论从哪一个点将数组分开，左右两边中必有一边是有序的

二分查找步骤：时间复杂度O(logN)

1. 定义三个指针：left、middle、right
2. 比较left是否小于middle，是则左半部分有序，否则右半部分有序
3. 判断要查找的元素是否在有序部分，是则继续在有序部分重复上述步骤，否则在另外的部分重复上述步骤，直到找到元素或者left>right

示意图：查找元素 3

实现代码如下

public int bSearch(int[] nums, int target) {
    if (nums == null || nums.length < 1) {
        return -1;
    }
    if (nums.length == 1) {
        return nums[0] == target ? 0 : -1;
    }

    //左下标
    int left = 0;
    //右下标
    int right = nums.length - 1;

    while (left <= right) {
        //计算中间下标
        int mid = (right + left) / 2;

        //定位到元素，返回下标
        if (nums[mid] == target) {
            return mid;
        }
        //左边部分有序
        if (nums[left] <= nums[mid]) {
            if (nums[mid] > target && nums[left] <= target) {
                //在左边
                right = mid - 1;
            } else {
                //在右边
                left = mid + 1;
            }
        } else {
            //右半部分有序
            if (nums[mid] < target && nums[right] >= target) {
                //在右边
                left = mid + 1;
            } else {
                //在左边
                right = mid - 1;
            }
        }
    }

    return -1;
}

3. 进阶：如果旋转数组中存在重复元素时有何影响？

如下旋转数组中存在多个重复元素，此时如何进行二分查找

由于left=right=middle，所以此时无法判断到底左右哪边元素时有序的，碰到这种情况时，我们需要缩小范围再次尝试。

在极端情况下，时间复杂度会下降到O(n)，即需要比较每一个元素。

代码相比于上述实现要做些许调整

public int bSearchWithSameData(int[] nums, int target) {
    if (nums == null || nums.length < 1) {
        return -1;
    }
    if (nums.length == 1) {
        return nums[0] == target ? 0 : -1;
    }

    //左下标
    int left = 0;
    //右下标
    int right = nums.length - 1;

    while (left <= right) {
        //计算中间下标
        int mid = (right + left) / 2;

        //定位到元素，返回下标
        if (nums[mid] == target) {
            return mid;
        }

        //如果判断左右和中间元素均相等，此时就无法判断到底左右哪边是有序的
        //所以，此时需要缩小范围再次进行判断。当发生此种情况是，时间复杂度最坏为O(n)
        if (nums[left] == nums[mid] && nums[mid] == nums[right]) {
            left++;
            right--;
        } else if (nums[left] <= nums[mid]) {
            //左边部分有序
            if (nums[mid] > target && nums[left] <= target) {
                //在左边
                right = mid - 1;
            } else {
                //在右边
                left = mid + 1;
            }
        } else {
            //右半部分有序
            if (nums[mid] < target && nums[right] >= target) {
                //在右边
                left = mid + 1;
            } else {
                //在左边
                right = mid - 1;
            }
        }
    }

    return -1;
}