想要精通算法和SQL的成长之路 - 旋转数组系列

前言

想要精通算法和SQL的成长之路 - 系列导航

一. 搜索旋转排序数组

原题链接

首先提炼一下重点信息：

• 数组升序。
• 数组有旋转特性（实际上也就是数组整体后移几位而已）
• 我们不可以用for循环进行O(N)的遍历

本题我们主要采取的中心思想是二分法，它最适用于这类有序的数组。对于本题而言，我们试想一下，数组由于被旋转了，那么数组的中心部分必定包含这种峰谷的特性：

• 峰谷左右两侧的数值都要更大一点，并且一个是数组最大值，一个是数组最小值。

那么我们采取二分法的时候，假设中间索引是mid。那么存在三种情况：

• 如果目标值就在mid位置，那么直接返回下标。
• 目标值在mid的左侧。我们在左侧继续二分。
• 目标值在mid的右侧。我们在右侧继续二分。

但是这种做法仅仅限于普通的有序数组，对于本题而言还要稍微改造下。对于本题而言，当我们把数组从中间一分为二的时候，可以发现：一定有一部分的数组是有序的。

• 有序数组在左侧。
  
• 有序数组在右侧
  

那么我们针对这两种情况（num[mid] != target的前提）：

如果左侧数组有序：

• 如果target的值在[num[left] , num[mid])之间。那么right = mid - 1。
• 否则target在mid右侧，left = mid + 1。

如果右侧数组有序：

• 如果target的值在(num[mid] , num[right]]之间。那么left = mid + 1。
• 否则target在mid左侧，right = mid -1 。

代码如下：

public int search(int[] nums, int target) {
    int left = 0, right = nums.length - 1, mid;
    while (left <= right) {
        mid = left + (right - left) / 2;
        if (target == nums[mid]) {
            return mid;
        }
        // 如果数组左侧有序
        if (nums[left] <= nums[mid]) {
            // 如果`target`的值在`[num[left] , num[mid])`之间
            if (target >= nums[left] && target < nums[mid]) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        } else {
            // 右侧数组有序，并且`target`的值在`(num[mid] , num[right]]`之间
            if (target > nums[mid] && target <= nums[right]) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
    }
    return -1;
}

二. 搜索旋转排序数组 II

原题链接

在第一题的基础上，增加了重复数字的情况。并且我们只需要判断数组中是否存在目标值即可。

那么我们在第一题的题解基础上需要做什么？

• 去重处理。

在我们不断地对子区间进行二分法查找的时候，由于存在重复值的情况。因此我们无法一定保证左侧或者右侧的数组是否有序。

• 例如：【3,1,2,3,3,3,3】，第一次二分之后，左侧：【3,1,2】，右侧：【3,3,3】，我们从代码角度是无法区分两侧数组是否有序的。
• 怎么办？我们将左侧边界或者右侧边界缩短。然后在新的区间内重新进行二分查找即可。

以左侧边界缩短为例：

if (nums[left] == nums[mid]) {
    left++;
    continue;
}

完整代码就是：

public boolean search(int[] nums, int target) {
    int left = 0, right = nums.length - 1, mid;
    while (left <= right) {
        mid = left + (right - left) / 2;
        if (target == nums[mid]) {
            return true;
        }
        if (nums[left] == nums[mid]) {
            left++;
            continue;
        }
        // 如果数组左侧有序
        if (nums[left] < nums[mid]) {
            // 如果`target`的值在`[num[left] , num[mid])`之间
            if (target >= nums[left] && target < nums[mid]) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        } else {
            // 右侧数组有序，并且`target`的值在`(num[mid] , num[right]]`之间
            if (target > nums[mid] && target <= nums[right]) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
    }
    return false;
}

三. 寻找旋转排序数组中的最小值

原题链接

这题在第一题的基础上，不再是找目标值，而是寻找最小值了。我们知道：

• 在我们二分法的基础上就决定了目标值一定在我们二分区间范围内。
• 二分过程中，必定有一边的数组是升序的。

那很简单，在我们求最小值的基础上：

• 如果num[mid] < num[right]，那么(mid,right] 这部分的数据我们肯定是不要的,因为这部分数据是升序。right = mid （最小值可能就是mid对应值）。借用官网的图：
  

• 如果num[mid] > num[right]，那么最小值部分肯定处于(mid, right]之间，我们左侧直接舍弃。left = mid + 1（最小值不可能是mid处，因为(mid, right]区间内存在峰谷）。
  

代码如下：

public int findMin(int[] nums) {
    int left = 0, right = nums.length - 1, mid;
    while (left < right) {
        mid = left + (right - left) / 2;
        if (nums[mid] < nums[right]) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return nums[left];
}

四. 寻找旋转排序数组中的最小值 II

原题链接

在第三题的基础上：存在重复数字，但依旧是找最小值。根据第二题的分析，我们只需要考虑一边的去重处理即可：

public int findMin(int[] nums) {
    int left = 0, right = nums.length - 1, mid;
    while (left < right) {
        mid = left + (right - left) / 2;
        // 在原来基础上，增加左侧|右侧 重复数字的去重操作即可。去重之后要在新的区间上做二分算法，这点要注意一下即可。
        if (nums[mid] == nums[right]) {
            right--;
            continue;
        }
        if (nums[mid] < nums[right]) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return nums[left];
}