关于旋转数的那些事

再刷lc过程中，经常会遇到有序数列旋转的问题。以下面6道题为例，从易入难总结一下。

1. 189 旋转数组
   题目要求，将一个有序的数组，再指定位置进行旋转（即右移）形成一个新的数组。比如
   输入: [1,2,3,4,5,6,7] 和 k = 3
   输出: [5,6,7,1,2,3,4]
   最后k个字符右移，超出边界的元素从左边进入，类似一个环。解决该类题目除了用暴力法（每个字符循环一次，循环k次）、环状替代（利用临时变量，把每个元素移到指定位置，如下图），
   
   推荐做法为反转，简单易懂，快速O(n)，省空间O(1)，具体做法为3次反转，整体反转，k前半部分反转，k后半部分反转。因为较简单，直接贴代码，如下，记得k取余。

public class Solution {
    public void rotate(int[] nums, int k) {
        k %= nums.length;
        reverse(nums, 0, nums.length - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.length - 1);
    }
    
    public void reverse(int[] nums, int l, int r) {
        while (l < r) {
            nums[l] = nums[l] ^ nums[r];
            nums[r] = nums[l] ^ nums[r];
            nums[l] = nums[l] ^ nums[r];
            ll++;
            r--;
        }
    }
}

2. 61.链表旋转
   同上一题类似，变成了链表的数据结构，依然可以用3次反转的思想进行操作，不过具体代码有点复杂，因为要知道链表的长度才可以进行两部分的反转操作，链表长度可以再反转整体链表时统计。代码就不贴了，可以自己尝试写下。简单的做法是利用链表的特性，直接挪动指针即可完成一组链表的转移。思路是利用循环替代的想法，找到旋转点（size-k%size) 将后半部分指针指向前半部分，前半部分指向null即可完成。代码相对简单，直接贴码

public ListNode rotateRight(ListNode head, int n) {
    if (head == null || head.next == null) 
        return head;
    ListNode dummy=new ListNode(0);
    dummy.next=head;
    ListNode fast=dummy,slow=dummy;

    int i = 0;
    for (; fast.next!=null; i++)
    	fast=fast.next;
    
    for (int j=i-n%i; j>0; j--)
    	slow=slow.next;
    
    fast.next=dummy.next;
    dummy.next=slow.next;
    slow.next=null;
    
    return dummy.next;
}

3. 33 再旋转数组（不重复）上搜索某数
   一个数组在某个未知点进行了旋转（也可能没有旋转），让在该数组中找指定的数，我们知道，在有序的数组上搜索可以用二分查找，时间复杂度为O(logN)，但在旋转的数组下还可以进行查找么，答案是可以的，有两种方法，第一种，首先判断该数组是否有旋转，如果开头0数字小于结尾length-1数字，则该数组一定是没有旋转的，如果是没有旋转数组，直接用二分查找就可以了。
   如果是旋转数组，首先通过二分查找找到旋转点，具体方法如下：找到中间值大于中间值+1的点。

private int findRotation(int[] nums) {
        int l = 0;
        int r = nums.length - 1;
        while (l < r) {
            int mid = (r + l) >>> 1;
            if (nums[mid] > nums[mid+1]) {
                return mid+1;
            } else if (nums[mid] > nums[0]) {
                l = mid + 1;
            } else {
                r = mid;
            }
        }
        
        return l;
    }

然后将数组分为两部分，如果target值大于nums[0]则在前部分，否则再后部分，利用二分查找即可完成。整体耗时用了2次二分，所以为O(logN).
第二种办法是直接查找，因为旋转递增数列无外乎就是下面两种情况，再根据target的位置，可以分为4种情形。没有旋转的为第一种情况

根据上图，可以写出代码

int l = 0;
int r = nums.length - 1;
while (l <= r) {
    int mid = (r+l) >>> 1;
    if (nums[mid] == target) {
        return mid;
    }
    // a情况 
    else if (nums[mid] >= nums[l]) {
        // 第1种情况
        if (nums[l] <= target && target < nums[mid]) {
            r = mid - 1;
        } else {
            l = mid + 1;
        }
    } else {
        if (nums[mid] < target && target <= nums[r]) {
            l = mid + 1;
        } else {
            r = mid - 1;
        }
    }
}

return -1;

4. 81在旋转数组（有重复）搜索某数
   题目跟上题类似，只是数组从不重复变为可重复，解法和时间复杂度上会有什么变化么？答案还是没有。但需要多做一些处理，当二分查找左边值与右边值相等时。我们需要去掉这些重复的值，将他们向一边靠拢即可 (r-- or l++），代码如下：

int l = 0;
int r = nums.length - 1;
while (l <= r) {
    while (l < r && nums[l] == nums[r]) {
        r--;
    }
    int mid = (r+l) >>> 1;
    if (nums[mid] == target) {
        return true;
    } else if (nums[mid] >= nums[l]) {
        if (nums[l] <= target && target < nums[mid]) {
            r = mid - 1;
        } else {
            l = mid + 1;
        }
    } else {
        if (nums[mid] < target && target <= nums[r]) {
            l = mid + 1;
        } else {
            r = mid - 1;
        }
    }
}

return false;

5. 153 寻找旋转数组（不重复）的最小值
   这回不是找具体值，而是找数组中旋转点右边的值。如果按照简单的想法，直接遍历数组，找到当前值比下一个值大的就ok了，如果没找到，则数组没有旋转，返回第一个数字。这样做的复杂度是O(n)。有没有加速的方法，O(n)再加速，只能选择分治的方法，其实想一下，还是可以实现的，当找到的mid点的下一个值小于mid值 或者 mid值的上一个点大于mid值，即完成了搜索。直接上代码：

if (nums.length == 0) {
    return -1;
} else if (nums.length == 1 || nums[0] < nums[nums.length-1]) {
    return nums[0];
}

int start = 0;
int end = nums.length - 1;
while (start <= end) {
    int mid = start + (end - start) / 2;
    if (nums[mid] > nums[mid+1]) {
        return nums[mid+1];
    } else if (nums[mid - 1] > nums[mid]) {
        return nums[mid];
    } else if (nums[mid] > nums[0]) {
        start = mid + 1;
    } else {
        end = mid - 1;
    }
}

return -1;

要注意边界问题，mid+1因为在取值时是向下取整，所以不会越界，但mid-1是可以变为-1的，所以再开始要加上判断，只有一个元素时直接返回。

6. 154寻找旋转数组（可重复）的最小值
   相信大家看到上一题时已经猜到了这道题，当数组有重复数据的时候，还可以用上面的方法么？答案是不行了，需要做一些修改，将重复的数据往左移。具体的写法就不贴了，再此要介绍一种更好的写法，可以统一解决153、154的问题。先贴代码再解释

int l = 0, r = nums.length - 1;
while (l < r) {
    int mid = (r + l) >>> 1;
    if (nums[mid] > nums[r]) {
        l = mid + 1;
    } else if (nums[mid] < nums[r]) {
        r = mid;
    } else {
        r--;
    }
}
return nums[l];

这个方法非常的巧妙，在于跟右边的对比而非左边，原因在于数组是上升序列当数组没有旋转时无法判断出正确答案，需要每次判断是否为旋转数组处理才可以，如下代码，显然不如判断右边简洁

int l = 0, r = nums.length - 1;
while (l < r) {
	// 判断是否已旋转，没有返回第一个元素
    if (nums[l] < nums[r]) {
        return nums[l];
    }
    int mid = (r + l) >>> 1;
    if (nums[mid] > nums[l]) {
        l = mid + 1;
    } else if (nums[mid] < nums[l]) {
        r = mid;
    } else {
        l++;
    }
}
return nums[l];