C语言算法题：轮转数组

一、题目

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

示例 1:

输入: nums = [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:

输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]

解释:

向右轮转 1 步: [99,-1,-100,3]
向右轮转 2 步: [3,99,-1,-100]

提示：

1 <= nums.length <= 10⁵
-2³¹ <= nums[i] <= 2³¹ - 1
0 <= k <= 105

进阶：

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

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

二、方法1：使用额外的数组

1、思路

用 n 表示数组的长度，遍历原数组，将原数组下标为 i 的元素放至新数组下标为 (i + k) mod n 的位置，最后将新数组拷贝至原数组即可。

2、代码

void rotate(int* nums, int numsSize, int k) {
    int arr[numsSize];
    for (int i = 0; i < numsSize; ++i) {
        arr[(i + k) % numsSize] = nums[i];
    }
    for (int i = 0; i < numsSize; ++i) {
        nums[i] = arr[i];
    }
}

3、复杂度分析

• 时间复杂度： O(n)O(n)，其中 nn 为数组的长度。
• 空间复杂度： O(n)O(n)。

三、方法2：环状替换

1、思路

方法1中，我们采用的中间变量是一个数组，这样不仅空间占用量大，而且容易在覆盖数据时造成数据丢失；所以我们可以换一种思路，采用中间变量temp ，将交换的变量暂时储存在 temp 当中，就可以有效的避免数据的丢失，并且减少了空间占用量。

环形替换，顾名思义通过循环替换，达成目的。

从位置 0 开始，令 temp = numsSize[0]，根据题目要求：位置 0 的数字要替换位置 (0 + k) mod n 的数字，令 x = (0 + k) mod n ，交换 temp 和 nums[x]，此时就完成了位置 x 的更新；然后令 next = (x + k) % numsSize ,.
再重复交换位置知道返回初始位置。

但是回到初始位置不代表我们将整个数组都遍历了一遍，需要从下一个未遍历的数开始遍历，直到所有数据都被遍历了一次。

用 n 表示数组的长度，遍历了 a 圈，该过程总共遍历了 b 个元素，那么我们就可以得到一个等式 an=bk，所以说 an 就是 n，k 的公倍数，又因为我们每次遍历返回开始遍历的位置就停止，所以 a 要尽可能的小，所以我们可以得出一个结论：an 是 n，k 的最小公倍数，记作 lcm(n,k) ，那么就可以进一步得到 b = lcm(n,k) / k，所以我们一共遍历了 gcd(n,k) 次。

图解如下：

2、代码

int gcd(int a,int b)
{
    return b ? gcd(b,a % b) : a;
}
void swap(int* a,int* b)
{
    int t = *a;
    *a = *b;
    *b = t;
}
void rotate(int* nums, int numsSize, int k) {
    k = k % numsSize;
    int count = gcd(k,numsSize);
    for(int start = 0;start < count;start++)
    {
        int x = start;
        int temp = nums[start];
        do
        {
            int next = (x + k) % numsSize;
            swap(&nums[next],&temp);
            x = next;
        }while(start != x);
    }
}

3、复杂度分析

• 时间复杂度：O(n)，其中 n 为数组的长度。每个元素只会被遍历一次。
• 空间复杂度：O(1)。我们只需常数空间存放若干变量。

四、方法3：数组翻转

1、思路

我们可以先将所有元素翻转，这样尾部的 k mod n 个元素就被移至数组头部，然后我们再翻转 [0,k mod n−1] 区间的元素和 [k mod n,n−1] 区间的元素即能得到最后的答案。

2、代码

void swap(int* a, int* b) {
    int t = *a;
    *a = *b, *b = t;
}

void reverse(int* nums, int start, int end) {
    while (start < end) {
        swap(&nums[start], &nums[end]);
        start += 1;
        end -= 1;
    }
}

void rotate(int* nums, int numsSize, int k) {
    k %= numsSize;
    reverse(nums, 0, numsSize - 1);
    reverse(nums, 0, k - 1);
    reverse(nums, k, numsSize - 1);
}

3、复杂度分析

• 时间复杂度：O(n)，其中 n 为数组的长度。每个元素被翻转两次，一共 n 个元素，因此总时间复杂度为 O(2n)=O(n)。
• 空间复杂度：O(1)。