力扣189：旋转数组

本篇记录旋转数组的三种解法！！

这是一个编程题，要求你写一个函数来实现数组的右旋转操作。有很多种方法可以解决这个问题，比如使用额外的空间，或者使用反转。我会用C++来写。

三次翻转法
我用C++来写一个函数来实现数组的右旋转操作。我使用反转的方法，因为它不需要额外的空间，而且时间复杂度是O(n)。代码如下：

// 定义一个函数，接受一个整数数组nums和一个非负数k作为参数
void rotate(vector<int>& nums, int k) {
    // 获取数组的长度n
    int n = nums.size();
    // 如果n为0或者1，或者k等于0或者n的倍数，那么不需要旋转，直接返回
    if (n == 0 || n == 1 || k == 0 || k % n == 0) return;
    // 否则，将k对n取模，得到实际需要旋转的步数
    k %= n;
    // 定义一个辅助函数，用来反转数组中指定区间的元素
    auto reverse = [&](int start, int end) {
        // 从两端向中间遍历，交换对应位置的元素
        while (start < end) {
            swap(nums[start], nums[end]);
            start++;
            end--;
        }
    };
    // 先反转整个数组
    reverse(0, n - 1);
    // 再反转前k个元素
    reverse(0, k - 1);
    // 最后反转剩余的元素
    reverse(k, n - 1);
}

开辟新数组方法
就是新建一个数组，将旋转后的元素复制到新数组中，然后再把新数组赋值给原数组。这种方法的时间复杂度也是O(n)，但是空间复杂度是O(n)。代码如下：

// 定义一个函数，接受一个整数数组nums和一个非负数k作为参数
void rotate(vector<int>& nums, int k) {
    // 获取数组的长度n
    int n = nums.size();
    // 如果n为0或者1，或者k等于0或者n的倍数，那么不需要旋转，直接返回
    if (n == 0 || n == 1 || k == 0 || k % n == 0) return;
    // 否则，将k对n取模，得到实际需要旋转的步数
    k %= n;
    // 新建一个和原数组一样大小的数组temp
    vector<int> temp(n);
    // 遍历原数组中的每个元素
    for (int i = 0; i < n; i++) {
        // 将原数组中第i个元素复制到新数组中第(i + k) % n个位置上
        temp[(i + k) % n] = nums[i];
    }
    // 将新数组赋值给原数组
    nums = temp;
}

还有一种方法是使用循环交换，就是每次将最后一个元素和前面的元素依次交换，直到交换k次。这种方法的时间复杂度是O(n * k)，空间复杂度是O(1)。代码如下：

// 定义一个函数，接受一个整数数组nums和一个非负数k作为参数
void rotate(vector<int>& nums, int k) {
    // 获取数组的长度n
    int n = nums.size();
    // 如果n为0或者1，或者k等于0或者n的倍数，那么不需要旋转，直接返回
    if (n == 0 || n == 1 || k == 0 || k % n == 0) return;
    // 否则，将k对n取模，得到实际需要旋转的步数
    k %= n;
    // 遍历k次
    for (int i = 0; i < k; i++) {
        // 记录最后一个元素的值
        int last = nums[n - 1];
        // 从右向左遍历数组中除了最后一个元素以外的其他元素
        for (int j = n - 2; j >= 0; j--) {
            // 将当前元素赋值给下一个元素
            nums[j + 1] = nums[j];
        }
        // 将最后一个元素的值赋值给第一个元素
        nums[0] = last;
    }
}

这个代码跑不了力扣的测试，因为在大量的数据下，时间复杂度太大