[LeetCode] (easy) 189.Rotate Array

https://leetcode.com/problems/rotate-array/

Given an array, rotate the array to the right by k steps, where k is non-negative.

Example 1:

Input: [1,2,3,4,5,6,7] and k = 3
Output: [5,6,7,1,2,3,4]
Explanation:
rotate 1 steps to the right: [7,1,2,3,4,5,6]
rotate 2 steps to the right: [6,7,1,2,3,4,5]
rotate 3 steps to the right: [5,6,7,1,2,3,4]

Example 2:

Input: [-1,-100,3,99] and k = 2
Output: [3,99,-1,-100]
Explanation: 
rotate 1 steps to the right: [99,-1,-100,3]
rotate 2 steps to the right: [3,99,-1,-100]

Note:

• Try to come up as many solutions as you can, there are at least 3 different ways to solve this problem.
• Could you do it in-place with O(1) extra space?

---

直观方法很显然，转k次，每次转一格，也确实是O(1)空间的，但是时间复杂度太高

我使用的直观方法二，将nums数组分为三段，分别为从尾巴挪到头上一段，需要从被覆盖的头部迁移的数据一段，尾部（不是挪到头部的尾巴）无需特殊处理的数据一段，长度分别为k,k,len-k，按照1、3、2的顺序处理，第三段处理时倒序

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int *tem = new int[k];
        k %= nums.size();
        for(int i = 0; i < k; ++i){
            tem[i] = nums[i];
            nums[i] = nums[nums.size()-k+i];
        }
        for(int i = nums.size()-1; i >= 2*k; --i){
            nums[i] = nums[i-k];
        }
        for(int i = 0; i < k && i+k<nums.size(); ++i){
            nums[k+i] = tem[i];
        }
    }
};

足够快，但空间复杂度太高

从别人那里抄来的第三种做法，先整个nums倒序，再将头尾两部分分别倒序，根据倒叙函数的设计，可以做到空间复杂度O(1)，真是妙啊

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int len = nums.size();
        k %= len;
        reverse(nums, 0, len-1);
        reverse(nums, 0, k-1);
        reverse(nums, k, len-1);
    }
    
    void reverse(vector<int>& nums, int lo, int hi) {   //左闭右闭
        int tem;
        while(lo < hi){
            tem = nums[lo];
            nums[lo] = nums[hi];
            nums[hi] = tem;
            ++lo;
            --hi;
        }
        return;
    }
};

当然也可以直接使用algorithm自带的reverse函数

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int len = nums.size();
        k %= len;
        reverse(nums.begin(), nums.end());
        reverse(nums.begin(), nums.begin()+k);
        reverse(nums.begin()+k, nums.end());
    }
    
};

但是这样还是到不了8ms，想要100%的话得加那句输入流优化。