最近太忙了都好久没有更新博客了,太难了
,抽空水一篇文章,大佬们多多支持.
前言
上节我们学习了算法的时间复杂度,今天来学习空间复杂度.
一、空间复杂度概念？
老规矩先上定义:
空间复杂度是对一个算法在运行过程中 临时占用存储空间大小的量度 。空间复杂度不是程序占用了多少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);
}总结:
1.空间复杂度
2.有关空间复杂度的OJ题
仓促之下水的文章,码文不易,各位看官给个三连呗,如有不足还望指出.