【算法】给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

首先要确定移动的最少位数，因为有可能k大于数组的长度，那移动过程中会有无意义的正好轮转到原先位置的情况，所以：移动最少位数 m = k % 数组长度

方法一：

已经确定了最少移动位数后，每一次的移动，我先把当前数组的最后一个元素end记录下来，然后从后往前遍历，把前一个节点的值赋给后一个节点，该次遍历结束后，把end赋给数组的第一个节点，这样就完成了一次移动，接着再开始下一次移动，代码如下：

    public void rotate(int[] nums, int k) {
        int length = nums.length;
        if(k % length == 0) {
            return;
        }
        int m = k % length;
        for(int i = 0; i < m; i++ ) {
            int end = nums[length - 1];
            for(int j = length -1; j > 0; j--) {
                nums[j] = nums[j-1];
            }
            nums[0] = end;
        }
    }

提交代码之后提示时间超时，这段代码确实很消耗时间，每一次移动都一个一个移。。。

方法二：

还是先确定最少移动次数，然后再看数组，移动m位，其实就是相当于在原数组的第m节点和第m+1节点之间分割开，后半部分的数组平移到前半部分数组之前，然后再拼接起来，或者说是把前半部分的数组平移到后半部分数组之后，然后再拼接起来，代码如下：

    public void rotate(int[] nums, int k) {
        int length = nums.length;
        int m = k % length;
        if(m == 0) {
            return;
        }
        int[] a = new int[length - m];
        int[] b = new int[m];
        a = Arrays.copyOfRange(nums, 0, length -m);
        b = Arrays.copyOfRange(nums, length-m, length);
        System.arraycopy(b, 0, nums, 0, b.length);
        System.arraycopy(a, 0, nums, b.length, a.length);
    }

有一个坑， Arrays.copyOfRange()接收三个参数， 分别是拷贝的数组，开始位置，结束位置(不包含该位置) 

这两个方法都是自己想出来的，记录一下

也看了其他的帖子，但是没有看到惊为天人的算法（bushi）

方法三：

这个方法是从别的帖子那里看来的，这个算法时间和空间消耗比较友好

    public void rotate(int[] nums, int k) {
        int length = nums.length;
        int m = k % length;
        if(m == 0) {
            return;
        }
        int[] temp = new int[length];
        temp = Arrays.copyOf(nums, length);
        for(int i = 0 ;i <length; i++) {
            int n = (i + k) % length;
            nums[n] = temp[i];
        }
    }