时间复杂度与空间复杂度2（空间换时间算法）

        在上一篇博客中，曾提到计算机行业的迅速发展，计算机的存储容量已经到达了很高的程度，因而不需要过多关注一个程序的空间复杂度。不仅如此，我们还可以通过开辟额外的内存空间来优化算法的时间复杂度，即空间换时间。

---

        以LeetCode第192题轮转数组为例，题目要求为：给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。

 

        关于类似的题目，一般从三个角度去思考，第一是暴力求解，第二是时间换空间，第三是巧妙的方法。

        1 .暴力求解

        暴力求解指的是用最简单，最直观，也是最低效的方法来解决问题。对此题而言，最简单直观的解决方法就是进行k次循环，每次循环先将最后一个元素拿出，再将所有元素后移，最后将拿出的元素置于开头的位置，代码如下：

void rotate(int* nums, int numsSize, int k)
{
    while (k)
    {
        //将最后一个元素拿出
        int tmp = nums[numSize - 1];
        
        //将所有元素后移
        for (int i = numSize - 1; i > 0; i--)
        {
            nums[i] = nums[i - 1];
        }
        
        //拿出元素置于开头
        nums[0] = tmp;

        //控制循环次数
        k--;
    }
}

        2 .空间换时间

        暴力求解需要进行k次循环，每次循环要执行n - 1次移动，因而时间复杂度为O(KN)，也可以认为是O(N^2)，时间效率比较低。第二种方法，空间换时间的思想就是动态开辟一块内存空间，将nums数组中的元素轮转后的结果放入新开辟的空间，最后再将其拷贝给nums数组，具体算法思想如下图所示：

         实际上，k次移动就是将数组中后k个元素放到了数组的前k个位置，将前numSize - k个元素放到了数组的后numSize - k个位置，需要注意的是数组下标的控制，代码如下：

void rotate(int* nums, int numsSize, int k)
{
    //动态开辟临时数组
    int* tmp = (int*)malloc(sizeof(int) * numSize);
    if (tmp == NULL)
    {
        perror("malloc fail!");
        exit(-1);
    }

    //将nums后k个元素放到tmp数组前k个位置
    for (int i = 0; i < k; i++)
    {
        tmp[i] = nums[numSize - k + i];
    }

    //将nums前numSize - k个元素放到tmp数组后numSize - k个位置
    for (int i = 0; i < numSize; i++)
    {
        tmp[k + i] = nums[i];
    }
    
    //将tmp数组中的元素拷贝给nums数组，并释放内存空间
    memcpy(nums, tmp, sizeof(int) * numSize);
    free(tmp);
    tmp = NULL;
}

        3 .巧妙地方法

        一般而言，设计一个巧妙的算法去解决一个具体的问题是很困难的，但是学习和掌握一种精妙的算法是相对比较简单的。因此，想要提升自己的代码和算法能力，就需要我们不断反复，多做，多练，尽可能多的去学习前人的经验，提升自己的思维。至于如何设计这些巧妙的算法，那就交给那些算法工程师吧！

        此题巧妙的算法思想如下：将数组nums分成两个部分，前numSize - k个元素和后看个元素，一次将这两个部分的元素反转，最后再将整个nums数组反转，就可以得到最终的结果,同时也需要注意数组下标的控制。具体算法思想和代码如下：

 

void reverse(int* begin, int* end)
{
    while (begin < end)
    {
        int tmp = *begin;
        *begin = *end;
        *end = tmp;
        begin++;
        end--;
    }
}

void rotate(int* nums, int numSize, int k)
{
    reverse(nums, nums + numSize - k - 1);
    reverse(nums + numSize - k, nums + numSize - 1);
    reverse(nums, nums + numSize - 1);    
}

---

        最后，我们在LeetCode上运行时，后两种方法会报错。原因是k的值有可能大于数组个数numSize，从而导致越界。解决方法也很简单，第一步先将k取模，其实很好理解，因为长度为numSize的数组，向右轮转numSize次，又变回了数组。

        最终代码如下：

void reverse(int* begin, int* end)
{
    while (begin < end)
    {
        int tmp = *begin;
        *begin = *end;
        *end = tmp;
        begin++;
        end--;
    }
}

void rotate(int* nums, int numSize, int k)
{
    k %= numSize;    

    reverse(nums, nums + numSize - k - 1);
    reverse(nums + numSize - k, nums + numSize - 1);
    reverse(nums, nums + numSize - 1);    
}