给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

示例 1:

输入: [1,2,3,4,5,6,7] 和 k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]
示例 2:

输入: [-1,-100,3,99] 和 k = 2
输出: [3,99,-1,-100]
解释: 
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]
说明:

尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
要求使用空间复杂度为 O(1) 的 原地 算法。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/rotate-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
        public void rotate(int[] nums, int k) {
//            rotateI(nums, k);
//            rotateII(nums, k);
//            rotateIII(nums, k);
            rotateIIII(nums, k);
        }

        //方法四：最大公约数
        //由方法二知道，数组nums的i元素被移到(k+i)%len的位置上
        private void rotateIIII(int[] nums, int k) {
            if (nums == null || nums.length <= 1) return;
            int len = nums.length;
            for (int i = 0; i < gcd(k, len); i++) {
                int index = (k + i) % len, num = nums[i];
                while (index != i) {
                    int temp = nums[index];
                    nums[index] = num;
                    num = temp;
                    index = (index + k) % len;
                }
                nums[i] = num;
            }
        }

        private int gcd(int a, int b) {
            return a % b == 0 ? b : gcd(b % a, a);
        }


        //方法三：反转法
        //1.假设数组长度为n，当旋转数组k次，k%n个尾部元素会被移到数组的头部，其他元素向后移动一位
        //2.先将这个数组反转
        //3.将数组的前k个元素反转，再将剩下的(n-k)个元素反转
        private void rotateIII(int[] nums, int k) {
            if (nums == null || nums.length <= 1) return;
            int len = nums.length;
            k %= len;
            reverse(nums, 0, len - 1);
            reverse(nums, 0, k - 1);
            reverse(nums, k, len - 1);
        }

        private void reverse(int[] nums, int left, int right) {
            while (left < right) {
                int temp = nums[left];
                nums[left] = nums[right];
                nums[right] = temp;
                left++;
                right--;
            }
        }

        //方法二：创建新数组a
        //1.将nums数组中的i元素移动新数组a的(i+k)%数组长度 的位置上
        //2.然后将新数组a的元素重新赋值到nums中
        private void rotateII(int[] nums, int k) {
            if (nums == null || nums.length <= 1) return;
            int len = nums.length;
            int[] a = new int[len];
            for (int i = 0; i < len; i++) {
                a[(i + k) % len] = nums[i];
            }
            for (int i = 0; i < len; i++) {
                nums[i] = a[i];
            }
        }

        //方法一：暴力法
        //旋转k次，每次数组中的元素都要旋转一次，时间复杂度为O(n*k)，空间复杂度O(1)
        private void rotateI(int[] nums, int k) {
            if (nums == null || nums.length <= 1) return;
            int previous,temp;
            for (int i = 0; i < k; i++) {
                previous = nums[nums.length - 1];
                for (int j = 0; j < nums.length; j++) {
                    temp = nums[j];
                    nums[j] = previous;
                    previous = temp;
                }
            }
        }
    }