算法复杂度-空间

一 . 空间复杂度

空间复杂度也是一个数学表达式 ， 是对一个算法在运行过程中因为算法的需要额外临时开辟的空间。

空间复杂度不是程序占用了多少个 bytes 的空间 ， 因为常规情况每个对象大小差异不会很大 ， 所以空间复杂度算的是变量的个数。

空间复杂度的计算规则基本跟时间复杂度类似 ， 也使用 大O渐进表示法。

注意 : 函数运行时所需要的栈空间（存储参数 ， 局部变量 ，一些寄存器信息等）在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时  额外申请的空间来确定。

二 . 空间复杂度计算示例

2.1 示例一 

// 计算BubbleSort的空间复杂度？
void BubbleSort(int* a, int n)
{
assert(a);
for (size_t end = n; end > 0; --end)
{
int exchange = 0;
for (size_t i = 1; i < end; ++i)
{
if (a[i-1] > a[i])
{
Swap(&a[i-1], &a[i]);
exchange = 1;
}
}
if (exchange == 0)
break;
}
}

函数栈帧在编译期间就已经确定好了 ， 只需要关注函数在运行时额外申请的空间就可以了。  BubbleSort 额外申请的空间是常数个，因此空间复杂度是    O（1） 

 2.2 示例2

// 计算阶乘递归Fac的空间复杂度？
long long Fac(size_t N)
{
if(N == 0)
return 1;
return Fac(N-1)*N;
}

Fac 递归调用了 N 次 ，额外开辟了 N个函数栈帧 ， 每个函数栈帧使用了常数个空间

因此空间复杂度是 ： O(N)  

三 . 常见复杂度对比

四 . 复杂度算法题

旋转数组 : . - 力扣（LeetCode）

解法一：

循环 k 次 将数组所有元素后移 一位  ---> 代码运行失败（时间超出限制）

void rotate(int* nums, int numsSize, int k) {
    while (k--) {
        int end = nums[numsSize - 1];
        for (int i = numsSize - 1; i > 0; i--) {
            nums[i] = nums[i - 1];
        }
        nums[0] = end;
    }
}

 注意 :  相同的如果空间复杂度太高 ， 也会报错 ： 超出空间限制

解法二：

申请新数组空间 ， 先将后  K个数据放在新数组中 ， 再将剩下的数据挪到新的数组中。 

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

时间复杂度 ： O(N)

空间复杂度  ： O(N)

以空间换时间的方法来提高算法性能的

解法三： 

三次逆转（逆置）：

第一次：前 n - k 个逆置

第二次 ：后 k 个逆置

第三次 ：整体逆置  

 按照以上分析 : 

//定义一个逆置的函数
void Reverse (int*arr,int begin ,int end)
{
    while(begin<end)
    {
        int temp = arr[begin];
        arr[begin] = arr[end];
        arr[end] = temp;

        end--;
        begin++;
    }
}
void rotate(int* nums, int numsSize, int k) {
    k = k % numsSize ;
    Reverse(nums,0,numsSize - 1-k);
    Reverse(nums,numsSize-k,numsSize-1);
    Reverse(nums,0,numsSize-1);
}

 时间复杂度 ： O(N)

空间复杂度  ： O(1)