Leetcode 189. 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]

共4种：想出3种方法（实际两种），参考了reverse的方法：

---

方法一： 借助一个Array，用copy的方式
先把nums的最后一个元素赋值给newArray第一位；后把nums从第0位后的n-1个元素整体复制到newArray。
这样操作k次。若k=3
第一步得到[7,1,2,3,4,5,6]
第二步得到 [6,7,1,2,3,4,5]
第三步得到 [5,6,7,1,2,3,4]

//新增加一个Array，将最后一个元素，一步步移动到最前面。
class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length;
        int[] rotateArr = new int[n];       
        for(int i=0; i<k; i++)
        {
            rotateArr[0] = nums[n-1];        
            System.arraycopy(nums,0,rotateArr,1,n-1);
            
            //把新生成的rotateArr复制到nums里，保证rotateArr[0] = nums[n-1];这一步是一直有效的
            System.arraycopy(rotateArr, 0, nums, 0, n); 
        }       	  
    }
}

时间复杂度： O(n)O(n) 。将数字放到新的数组中需要一遍遍历，另一边来把新数组的元素拷贝回原数组。
空间复杂度： O(n)O(n)。另一个数组需要原数组长度的空间；
————————————————————————————

方法二 不需要额外数组： for+ for循环，数组依次后移，把最后一位赋值给第一位，操作K次

//把最后一位拿到第一位，循环k次，不需要新增一个数组。
class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length;      
        for(int i=0; i< k; i++)//循环k次
        { 
            int rear = nums[n-1];
            //数组依次后移
            for(int j = n-1; j> 0; j--)
            {
                nums[j]=nums[j-1];
            }
            nums[0] = rear; //最后一位拿到第一位
        }           
    }
}

空间复杂度：O(1)O(1) 。没有额外空间被使用。

---

方法三 不需要额外数组： while+ for循环，比上一个写法快一倍

//rotate k 次。从a[1]到a[n-1]依次与0位调换。
class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length; 
        while(k>0)//调换k次
        {
             for(int i = 1; i<n;i++)
            {
                int temp = nums[0];
                nums[0] = nums[i];
                nums[i] = temp;
            }
            k--;   
        }
    }
}

---

方法四：分而治之，分段翻转。

//rotate k 次。分而治之，分段翻转，之后再整体翻转
/*
翻转[1,2,3,4]部分，得到[4,3,2,1,5,6,7]
翻转[5,6,7]部分，得到[4,3,2,1,7,6,5]
翻转整个数组，得到[5,6,7,1,2,3,4]
*/
class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length; 
        if (nums.length == 0 || nums.length == 1 || k % nums.length == 0)
            return;
        k %= nums.length;
        int length = nums.length;
        reverse(nums, 0, length - k - 1);
        reverse(nums, length - k, length - 1);
        reverse(nums, 0, length - 1);
    }
 
    private void reverse(int[] nums, int begin, int end) {
        for (int i = 0; i < (end - begin + 1) / 2; i++) {
            int temp = nums[begin + i];
            nums[begin + i] = nums[end - i];
            nums[end - i] = temp;
        }
    }
    
}

时间复杂度：O(n)。 n 个元素被反转了总共 3 次。
空间复杂度：O(1)。 没有使用额外的空间