前言

上节我们学习了算法的时间复杂度,今天来学习空间复杂度.

一、空间复杂度概念？

老规矩先上定义:

空间复杂度是对一个算法在运行过程中 临时占用存储空间大小的量度 。空间复杂度不是程序占用

了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度计

算规则基本跟实践复杂度类似，也使用 大O渐进表示法 。

前一篇关于时间复杂度我们知道计算空间复杂度并不是计算算法的执行时间,算的是算法的执行次数,而空间复杂度同理,不算空间,算的是变量的个数.它同样和时间复杂度一样是 一个估算,与时间复杂度的规定大同小异.

二、实例展示

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;
 }
}

解析:空间复杂度也是用大O渐进法,类似于时间复杂度的方式,是去计算变量的个数, 如上冒泡排序的空间复杂度是O(1) ,变量有 a,n,szie_t end,size_t i,exchange.总共是常数5个,常数都看作是 1,所以空间复杂度是O(1).

这里我们要注意,时间是可以累计的,而空间是不累计的,也就是说时间用完了还存在,而空间被开辟后用完可以丢弃销毁,比如:一个循环走了N次,它重复利用的是一个空间.用不到了就可以被销毁;递归同样也是一个道理,在递归时开辟了一块又一块的空间,当计算往下走时,保留空间,返回时,用不到的空间就会被销毁.

2.斐波那契数:

// 计算Fibonacci的空间复杂度？
long long* Fibonacci(size_t n)
{
     if(n==0)
          return NULL;
     long long * fibArray = (long long *)malloc((n+1) * sizeof(long long));

     fibArray[0] = 0;
     fibArray[1] = 1;
     for (int i = 2; i <= n ; ++i)
     {
           fibArray[i ] = fibArray[ i - 1] + fibArray [i - 2];
     }
     return fibArray ;
}

解析:(malloc的意思是开辟了 n+1 个 long long 类型变量的数组).

计算变量个数有 n, fibArray, fibArray[0], fibArray[1], i 一共 5 个,但是我们还看见 malloc 函数中有 (n+1) ,所以空间复杂度是 O(N+6) ,随着N的增大, +6 的影响对其影响不大,所以可以忽略不计,最后斐波那契数的空间复杂度是 O(N) .

(大多数情况下,算法的空间复杂度都是O(1),都是常数个变量,此代码中 malloc 是开辟了一个数组.)

3.阶乘递归:

// 计算阶乘递归Factorial的空间复杂度？
long long Factorial(size_t N)
{
 return N < 2 ? N : Factorial(N-1)*N;
}

解析: 这个代码我们知道,递归调用了 N 次,每一次都调用建立一个栈帧,每个栈帧使用了常数个空间,也就是一次递归的空间复杂度是 O(1) ,而调用了 N 次递归,空间复杂度就是 O(N) .

(虽然递归调用返回时空间销毁,但是我们仍要计算它,可以理解为计算时间复杂度的最坏情况,)

三、.有复杂度要求的算法题练习

1.题目链接：力扣--消失的数字

思路一:

数组nums包含 0 ~ n 的所有整数,要找出其中缺的那一个数字,我们按将其数组元素进行排序,例如: [2 ,3, 1, 4, 5, 7, 6, 9],将其排序之后就会变成[1,2,3,4,5,6,7,9].然后就很简单了,要找到消失的数就可以将排序后的元素遍历一遍,看后一个数是不是比前一个数大1,如果不是那就直接找到了.

代码如下:

int missingNumber(int* nums, int numsSize){
    for(int i = numsSize - 1; i > 0; i--)
    {
        //冒泡排序
        flag = 1;
        for(int j = 0; j < i; j++)
        {
            if(nums[i] > nums[i + 1])
            {
                int tmp = nums[i];
                nums[i] = nums[i + 1];
                nums[i + 1] = tmp;
                if(flag)
                    flag = 0;
            }
            if(flag)
                break;
        }
    }
    //检查每个元素前后是否相差为1
    for(int z = 0; z < numsSize - 2; z++)
    {
        if(nums[z + 1] - nums[z] != 1)
            return nums[z + 1] - 1;
    }    
    //考虑头尾
    if(nums[0])
    return 0;
    return numsSize;
}

但是题目要求算法的时间复杂度要求是 O(N) ,如果使用最快的排序只能达到O(N*logN),所以排序并不合适.

思路二:

要求 0 ~ n 中缺失的那个,可以将 0 ~ n 的所有元素相加,得到的结果再与原数组里元素的和相减,结果就得到消失的数字.

代码如下:

int missingNumber(int* nums, int numsSize){
    int misNum = 0;
    for(int j = 0; j < numsSize + 1; j++)
    misNum += j;
    for(int i = 0; i < numsSize; i++)
    misNum -= nums[i];
    return misNum;
}

思路三:

异或:将数组中的数依次跟 0 ~ n 的所有数异或,最后剩下的数据就是缺的那个数字(异或:按位异或相同为 0 ,不同为 1 ).

举例如下:

我们知道相同的数异或到一起就没了,是0. 此题如果把 0 ~ n 的数与原数组里的元素进行异或,然后相同的两个数异或没了,那么剩下的就是消失的那个数,(两数组进行异或时不需要有序,因为异或满足交换律,相同的会消失,最后剩下的就是要求的数)

举例验证:

这个例子我们可以看到虽然数据没有有序,但是相同的两个数被相互消去,得到的是不同的那个数.

代码如下:

int missingNumber(int* nums, int numsSize){
    int x = 0;
    //用for循环求出数组中的异或之和
    for(int i = 0; i < numsSize; i++)
       x ^= nums[i];
    for(int j = 0; j < numsSize + 1; j++)//原数组比0~n少1个数,要+1
    //再和(0~n)之间的数异或
       x ^= j;
    return x;
}

2.题目链接：力扣--旋转数组

思路一:

如果要进行一次旋转,有数组 [1,2,3,4,5,6,7,8,9] ,可以先将数组中的最后末尾元素 9 存放到一个变量中,然后将最后一个元素之前的数据依次向后挪动,我们可以定义一个变量 end ,将它依次减减,就可以将元素依次挪动,直到最后首元素空出,再将 9 放进去,这样就完成了旋转了一次,

代码如下:

void rotate(int* nums, int numsSize, int k)
{
    for(int i=0;i<k;++i )
    {
        //旋转一次
        int tmp=0;
        tmp=nums[numsSize-1];
        for(int end=numsSize-2;end>=0;end--)
        {
            nums[end+1]=nums[end];
        }
        nums[0]=tmp;
    }
}

当前代码的时间复杂度是O(N*K),效率太低.

思路二:

以空间换时间:创建一个新的数组，首先将后 k 个数放到新数组的前 k 项里面，然后再将剩下的数放到新数组里面，(也就是将原数组分两段存放到一个新的数组中)

最后第二个循环是将新数组的内容替换掉原数组中的内容

代码如下:

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

numsSize取余是为了防止k的大小长度超过numsSize, 这样的解法时间复杂度符合要求，但是需要额外的空间实现

思路三:

有数组 [1,2,3,4,5,6,7]

先将数组的后 k 个逆置: [1,2,3,4,7,6,5]

再将前 n - k 个逆置: [4,3,2,1,7,6,5]

再整体逆置:[5,6,7,1,2,3,4]

代码如下:

void Reverse(int* nums, int left, int right)
{
	while (left < right)
	{
		int tmp = nums[left];
		nums[left] = nums[right];
		nums[right] = tmp;
		++left;
		--right;
	}
}
void rotate(int* nums, int numsSize, int k)
{
	if (k >= numsSize)
	{
		k %= numsSize;
	}

	Reverse(nums, numsSize - k, numsSize - 1);
	Reverse(nums, 0 , numsSize -k - 1);
	Reverse(nums, 0 , numsSize - 1);

}