題目描述

將包含 n 個元素的陣列向右旋轉 k 步。

例如，如果 n = 7 , k = 3，給定陣列 [1,2,3,4,5,6,7] ，向右旋轉後的結果為 [5,6,7,1,2,3,4]。

注意：
儘可能找到更多的解決方案，這裡最少有三種不同的方法解決這個問題。

提示:
要求空間複雜度為 O(1)

解法1

藉助O(n)$O(n)$的空間解法。再利用(i + k) % n = 旋轉後的位置，可以將原有陣列中的資料複製到新陣列中。

例如：

3元素在陣列中的2位置上，(2+3) % 7 = 5
5元素在陣列中的4位置上，(4+3) % 7 = 0
6元素在陣列中的5
 
位置上，(5+3) % 7 = 1
7元素在陣列中的6位置上，(6+3) % 7 = 2

根據以上可以推斷出，諸如將一個數組向右偏移或者旋轉多少步等之類的題目，可以通過(元素位置+偏移或旋轉步數) 模與 陣列長度可以得到偏移或者旋轉之後的元素位置。

程式碼：

@Test
public void test() {
    Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5, 6, 7}, rotate(new int[]{1, 2, 3, 4, 5, 6, 7}, 0));
    Assert.assertArrayEquals(new
 
 int[]{7, 1, 2, 3, 4, 5, 6}, rotate(new int[]{1, 2, 3, 4, 5, 6, 7}, 1));
    Assert.assertArrayEquals(new int[]{6, 7, 1, 2, 3, 4, 5}, rotate(new int[]{1, 2, 3, 4, 5, 6, 7}, 2));
    Assert.assertArrayEquals(new int[]{5, 6, 7, 1, 2, 3, 4}, rotate(new int[]{1, 2, 3, 4, 5, 6, 7}, 3));
    Assert.assertArrayEquals(new
 
 int[]{4, 5, 6, 7, 1, 2, 3}, rotate(new int[]{1, 2, 3, 4, 5, 6, 7}, 4));
    Assert.assertArrayEquals(new int[]{3, 4, 5, 6, 7, 1, 2}, rotate(new int[]{1, 2, 3, 4, 5, 6, 7}, 5));
    Assert.assertArrayEquals(new int[]{2, 3, 4, 5, 6, 7, 1}, rotate(new int[]{1, 2, 3, 4, 5, 6, 7}, 6));
    Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5, 6, 7}, rotate(new int[]{1, 2, 3, 4, 5, 6, 7}, 7));
    Assert.assertArrayEquals(new int[]{2, 1}, rotate(new int[]{1, 2}, 1));
    Assert.assertArrayEquals(new int[]{2, 1}, rotate(new int[]{1, 2}, 3));
}

public int[] rotate(int[] nums, int k) {

    k =  k % nums.length;

    int[] result = new int[nums.length];

    for (int i = 0; i < nums.length; i++) {
        result[(i + k) % nums.length] = nums[i];
    }

    return result;
}

解法2

可以採取反轉的方法，先反轉前n-k個元素，再反轉後k個元素，然後再將整個陣列反轉，就能得到該陣列旋轉k個元素的結果了

@Test
public void test1() {
    Assert.assertArrayEquals(new int[]{7, 1, 2, 3, 4, 5, 6}, rotate1(new int[]{1, 2, 3, 4, 5, 6, 7}, 1));
    Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5, 6, 7}, rotate1(new int[]{1, 2, 3, 4, 5, 6, 7}, 0));
    Assert.assertArrayEquals(new int[]{6, 7, 1, 2, 3, 4, 5}, rotate1(new int[]{1, 2, 3, 4, 5, 6, 7}, 2));
    Assert.assertArrayEquals(new int[]{5, 6, 7, 1, 2, 3, 4}, rotate1(new int[]{1, 2, 3, 4, 5, 6, 7}, 3));
    Assert.assertArrayEquals(new int[]{4, 5, 6, 7, 1, 2, 3}, rotate1(new int[]{1, 2, 3, 4, 5, 6, 7}, 4));
    Assert.assertArrayEquals(new int[]{3, 4, 5, 6, 7, 1, 2}, rotate1(new int[]{1, 2, 3, 4, 5, 6, 7}, 5));
    Assert.assertArrayEquals(new int[]{2, 3, 4, 5, 6, 7, 1}, rotate1(new int[]{1, 2, 3, 4, 5, 6, 7}, 6));
    Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5, 6, 7}, rotate1(new int[]{1, 2, 3, 4, 5, 6, 7}, 7));
    Assert.assertArrayEquals(new int[]{2, 1}, rotate1(new int[]{1, 2}, 1));
    Assert.assertArrayEquals(new int[]{2, 1}, rotate1(new int[]{1, 2}, 3));
}

public int[] rotate1(int[] nums, int k) {
    reverse(nums, 0, nums.length - 1 - k);
    reverse(nums, nums.length - k, nums.length - 1);
    reverse(nums, 0, nums.length - 1);
    return nums;
}

private void reverse(int[] nums, int start, int end) {
    while (start < end) {
        int tmp = nums[start];
        nums[start++] = nums[end];
        nums[end--] = tmp;
    }
}

解法3

依舊可以利用(i+k)%n等於新i的思路，不過這次是每次調換一個元素，後一個元素的調換基於上一個的位置。

例如：讓陣列[1,2,3,4,5,6,7]向右旋轉1，可以按照以下步驟來：

// 1
// 1, 2, 3, 4, 5, 6, 7

//       3
// 1, 2, 1, 4, 5, 6, 7

//             5
// 1, 2, 1, 4, 3, 6, 7

//                   7
// 1, 2, 1, 4, 3, 6, 5

//    2
// 1, 7, 1, 4, 3, 6, 5

//          4
// 1, 7, 1, 2, 3, 6, 5

//                6
// 1, 7, 1, 2, 3, 4, 5

// 1
// 6, 7, 1, 2, 3, 4, 5

public void rotate2(int[] nums, int k) {
    if (nums.length == 0 || (k %= nums.length) == 0) {
        return;
    }
    int length = nums.length;
    int start = 0;
    int i = 0;
    int cur = nums[i];
    int cnt = 0;

    while (cnt++ < length) {
        i = (i + k) % length;
        int t = nums[i];
        nums[i] = cur;
        if (i == start) {
            ++start;
            ++i;
            cur = nums[i];
        } else {
            cur = t;
        }
    }
}