Leetcode刷題Java189. 旋轉數組

給定一個數組，將數組中的元素向右移動 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;
                }
            }
        }
    }