每日一题——力扣189. 轮转数组

. - 力扣（LeetCode）

#include <stdlib.h> // 包含标准库头文件，提供内存分配和其他常用函数
#include <string.h> // 包含字符串操作函数的头文件


// 定义一个函数，用于将数组元素向右循环移动 k 个位置
void rotate(int* nums, int numsSize, int k) {
    if(numsSize==1) // 如果数组大小为1，无需进行操作，直接返回
        return;
    int *buffer1,*buffer2; // 定义两个缓冲数组指针
    int i,SIZE_INT=sizeof(int); // 定义循环变量和整型数据的大小
    k%=numsSize; // 计算实际需要移动的步数（k对数组大小取模）
    
    // 分配第一个缓冲数组的内存，用于存储前 numsSize-k 个元素
    buffer1=(int*)malloc((numsSize-k)*SIZE_INT);
    for(i=0;i<numsSize-k;i++) // 将前 numsSize-k 个元素复制到第一个缓冲数组中
    {
        buffer1[i]=nums[i];
    }
    
    // 分配第二个缓冲数组的内存，用于存储后 k 个元素
    buffer2=(int*)malloc(k*SIZE_INT);
    for(i=0;i<k;i++) // 将后 k 个元素复制到第二个缓冲数组中
    {
        buffer2[i]=nums[numsSize-k+i];
    }
    
    // 将第二个缓冲数组的元素复制到数组的开头
    memcpy(nums,buffer2,k*SIZE_INT);
    // 将第一个缓冲数组的元素复制到数组的末尾
    memcpy(nums+k,buffer1,(numsSize-k)*SIZE_INT);
    free(buffer1);
    free(buffer2);
}

这段代码主要运用了以下编程思想：

1. 模块化设计：通过定义一个函数来完成特定的任务，使得代码组织结构清晰，有利于维护和复用。

2. 空间换时间：这是一种常见的优化思想。在这段代码中，通过使用额外的缓冲区存储元素，可以减少元素的移动次数，提高代码运行效率。

3. 资源管理：程序在使用完资源（如内存）之后，都进行了释放。这体现了良好的资源管理习惯，避免了内存泄漏等问题。

4. 直接访问和操作内存：通过使用malloc函数分配内存，memcpy函数复制内存等手段，直接对内存进行操作。这是C语言的特性之一，也是其运行效率高的原因之一。

从计算机科学的角度来看，这段代码反映了抽象的思想。即在旋转数组这个问题中，我们并不关心数组中元素的具体含义，只关心其在数组中的位置。

有没有优化时间复杂度或空间复杂度的方法?

对于数组旋转问题，确实存在时间复杂度更优的方法，这里介绍一种时间复杂度为O(n)、空间复杂度为O(1)的方法，即三次反转法。这种方法避免了使用额外的存储空间，直接在原数组上操作。

三次反转法的步骤如下：

1. 反转整个数组：首先将整个数组反转，这样原本数组尾部的k个元素会移动到数组的前面。
2. 反转数组的前k个元素：然后将前k个元素反转，恢复这些元素的原始顺序。
3. 反转数组剩余的部分：最后，反转数组剩余的部分，也就是从索引k到数组的末尾。

这里是具体的实现代码：

#include <stdlib.h> // 包含标准库头文件，提供内存分配和其他常用函数
#include <string.h> // 包含字符串操作函数的头文件

// 函数用于反转数组中从start到end的元素
void reverse(int* nums, int start, int end) {
    while (start < end) {
        int temp = nums[start];
        nums[start] = nums[end];
        nums[end] = temp;
        start++;
        end--;
    }
}

// 定义一个函数，用于将数组元素向右循环移动 k 个位置
void rotate(int* nums, int numsSize, int k) {
    k %= numsSize; // 计算实际需要移动的步数（k对数组大小取模）
    reverse(nums, 0, numsSize - 1); // 反转整个数组
    reverse(nums, 0, k - 1); // 反转数组的前k个元素
    reverse(nums, k, numsSize - 1); // 反转数组剩余的部分
}

这种方法的优点是不需要额外的存储空间，且只需要遍历数组三次，因此时间复杂度为O(n)，空间复杂度为O(1)。