“Rotate sorted array”系列问题

给定一个排序的数组，进行数组旋转之后引出了一系列的问题，这里将遇到的相关问题做一个总结，并给出解决方法，备用所需。

有序数组旋转操作

这个问题是所有系列问题的起始，给一个有序数组，使用这个操作进行旋转，得到的数组就可以以之为其他问题的基础进行引申。

Rotate an array of n elements to the right by k steps.
For example, with n = 7 and k = 3, the array [1,2,3,4,5,6,7] is rotated to [5,6,7,1,2,3,4].

这个问题的解决思路有如下几个：
1. 单独申请一个数组，将下标间隔之后进行拷贝
2. 将前n-k个元素添加到后面，然后将前面的n-k个元素删除（利用vector的push_back和erase）
3. 进行原地操作，常数级的空间

上述思路的第三个比较巧妙，使用常数级的原地操作。代码如下：

void rotate(int* nums, int numsSize, int k) {    int prev = numsSize > 0 ? nums[0] : 0, next = prev;    int i = 0, j = 0;    for(int n = 0; n < numsSize; ++n)    {        i = (i + k) % numsSize;        prev = next;        next = nums[i];        nums[i] = prev;        if (i == j) //关键所在，如果出现重复，需要进行偏移操作        {            next = nums[++j];            i++;        }    }}

寻找最小值（无重复元素）

对于旋转过的有序数组，如果没有重复元素，那么依然可以利用有序性质来进行二分查找，来寻找元素，首先是寻找最小值。
这里假定数组的顺序是升序的，利用的原理依然是通过中间元素与首尾元素之间的关系。如果中间元素大于首元素，则从首元素到中间元素间（包含边界）都是有序的，无序部分在后一半区间，此时如果尾元素小于中间元素，则最小值在后半区间，否则在前半区间；如果中间元素小于首元素，则一定是尾部的较大元素被旋转到了头部，后半区间是有序的，最小值肯定在包括中间元素的前半区间。
上述思路的递归版本代码实现如下，时间复杂度是O(logN)。

    int findMin(vector<int>& nums) {        return findMinHelper(nums, 0, nums.size() - 1);    }    int findMinHelper(vector<int> & a, int s, int e)    {        if (s == e) return a[s];        int m = (s + e) / 2;        if (a[m] > a[s])        {            if (a[e] < a[m]) return findMinHelper(a, m + 1, e);            else return findMinHelper(a, s, m);        }        else        {            return findMinHelper(a, s, m);        }    }

寻找最小值（有重复元素）

当存在重复元素时，需要考虑中间元素与首元素相等的情况：此时需要考虑两边，进行查找之后比较大小。其他情况类似。此时最差情况可能出现全部元素都相同，最差情况的复杂度为O(N)。

    ///递归版本    int findMin(vector<int>& nums) {        return findMinHelper(nums, 0, nums.size() - 1);    }    int findMinHelper(vector<int> & a, int s, int e)    {        if (s == e) return a[s];        int m = (s + e) / 2;        if (a[m] == a[s])        {            int l = findMinHelper(a, s, m);            int r = findMinHelper(a, m, e);            return l > r ? r : l;        }        else if(a[m] > a[s])        {            if (a[e] < a[m]) return findMinHelper(a, m + 1, e);            else return findMinHelper(a, s, m);        }        else        {            return findMinHelper(a, s, m);        }    }    ///非递归版本    int findMin(vector<int> & nums)    {        int l = 0, r = nums.size() - 1;        while(l < r)        {            int m = l + (r - l) / 2;            if (nums[m] == nums[l])            {                if (nums[r] >= nums[m]) --r;                else ++l;            }            else if (nums[m] > nums[l])            {                if (nums[r] < nums[m]) l = m + 1;                else r = m;            }            else r = m;        }        return nums[l];    }

查找指定元素（无重复元素）

Suppose a sorted array 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.

当没有重复元素时，套用前面的查找最小元素的思路即可：

int search(vector<int> & nums, int target){    int l = 0, r = nums.size() - 1;    while(l < r)    {        int m = l + (r - l) / 2;        if (nums[m] == target) return m;        if (nums[m] > nums[l])        {            //target在前半区间，target可能等于首元素，故大于等于号不可少            if (target < nums[m] && target >= nums[l]) r = m - 1;            else l = m + 1;        }        else        {            //target在后半区间，target可能等于尾元素，大于等于号不可少            if (target > nums[m] && target <= nums[r]) l = m + 1;            else r = m - 1;        }    }    if (l == r && nums[l] == target) return l;    return -1;}

查找指定元素（有重复元素）

套用前面的有重复元素查找最小元素的思路，针对相等的情况进行区别对待即可。下面为非递归版本，递归版本与前面类似。

    int search(vector<int> & nums, int target)    {        int l = 0, r = nums.size() - 1;        while(l < r)        {            int m = l + (r - l) / 2;            if (nums[m] == target) return m;            if (nums[m] == nums[l])            {                if (nums[r] >= nums[m]) --r;                else ++l;            }            else if (nums[m] > nums[l])            {                if (target >= nums[l] && target < nums[m]) r = m - 1;                else l = m + 1;            }            else            {                if ( target > nums[m] && target <= nums[r]) l = m + 1;                else r = m - 1;            }        }        return nums[l];    }