算法的空间复杂度

目录

常见时间复杂度计算示例

示例7

示例8单独递归

BT升级

示例9双度递归

答案分析

算法的空间复杂度

常见空间复杂度计算示例

示例1

示例2

示例3单独递归

BT升级双度递归

答案分析

常见复杂度对比

---

今天来介绍算法的空间复杂度&算法复杂度的题目。

常见时间复杂度计算示例

上篇博文我们讲到了实例6。今天接着讲解。

示例7

计算BinarySearch的时间复杂度？（二分查找的时间复杂度）

【二分查找复习】：分支语句与循环语句——练习_唐唐思的博客-CSDN博客

int BinarySearch(int* a, int n, int x)
{
	assert(a);
	int begin = 0;
	int end = n - 1;
	// [begin, end]：begin和end是左闭右闭区间，因此有=号
	while (begin <= end)
	{
		int mid = begin + ((end - begin) >> 1);
		if (a[mid] < x)
			begin = mid + 1;
		else if (a[mid] > x)
			end = mid - 1;
		else
			return mid;
	}
	return -1;
}

• 最好的情况1次
• 最坏的情况N/2/2/2..../2=1 （也就是找了多少次，除了多少个2）
• O(X)时间复杂度，X可以代表次数，循环的次数/数组的大小，整个算法效率的容量大小等
• 时间复杂度是调用的次数
• log以2为底x的对数N。底数2比较难写所以在数据结构中我们简化成：logN，默认以2为底。
• 只有2可以省略，其他4 5等等都不可以省略。博客书上写成lgN,与数学容易混淆不建议这样写

二分查找的有一个非常重要的前提是有序数组！！对比普通暴力查找算法，它是很厉害的。

暴力查找：O(N)

二分查找：O(logN)

虽然二分查找效率很高，但是前提是有序，即便用了效率很高的排序，但是后期增删查改很麻烦。进阶数据结构我们会学习AVL树 红黑树 哈希表。

示例8单独递归

计算阶乘递归Fac的时间复杂度？递归调用是多次调用累加

时间复杂度：O(N)  

long long Fac(size_t N)
{
	if (0 == N)
		return 1;
	return Fac(N - 1) * N;
}
//每次递归都是O(1) 叠加N+1次

 

BT升级

计算阶乘递归Fac的时间复杂度？递归调用是多次调用累加。

时间复杂度：O(N^2)

long long Fac(size_t N)
{
	if (0 == N)
		return 1;
	for (size_t i = 0; i < N; ++i)
	{
		//.....
	}
	return Fac(N - 1) * N;
}

 

示例9双度递归

计算斐波那契递归Fib的时间复杂度？

时间复杂度：O(2^N)

long long Fib(size_t N)
{
	if (N < 3)
		return 1;
	return Fib(N - 1) + Fib(N - 2);
}

虽然斐波那契数列求和用递归的方法思想非常简单，但是实践意义不大。因为它的时间复杂度太高。在之前递归篇章，我们也讲过用【迭代】的方法去解决【斐波那契数列问题】。它的时间复杂度就是O(N)，大大的提高了时间效率。 

答案分析

• 实例2基本操作执行了2N+10次，通过推导大O阶方法知道，时间复杂度为 O(N)
• 实例3基本操作执行了M+N次，有两个未知数M和N，时间复杂度为 O(N+M)
• 实例4基本操作执行了10次，通过推导大O阶方法，时间复杂度为 O(1)
• 实例5基本操作执行最好1次，最坏N次，时间复杂度一般看最坏，时间复杂度为 O(N)
• 实例6基本操作执行最好N次，最坏执行了(N*(N+1)/2次，通过推导大O阶方法+时间复杂度一般看最坏，时间复杂度为 O(N^2)
• 实例7基本操作执行最好1次，最坏O(logN)次，时间复杂度为 O(logN) ps：logN在算法分析中表示是底数为2，对数为N。有些地方会写成lgN。（建议通过折纸查找的方式讲解logN是怎么计算出来的）
• 实例8通过计算分析发现基本操作递归了N次，时间复杂度为O(N)。
• 实例9通过计算分析发现基本操作递归了2^N次，时间复杂度为O(2^N)。（建议画图递归栈帧的二叉树讲解）

算法的空间复杂度

空间复杂度是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度 。空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

算法逻辑需求 所需要补充的额外的空间。

• 空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。
• 空间复杂度计算规则基本跟实践复杂度类似，也使用大O渐进表示法。
• 注意：函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。
• 算法的空间复杂度一般都是O(1)/O(N)，还是取决于额外开辟的空间是多少，像快速排序的空间复杂度就是O(logN)

常见空间复杂度计算示例

空间复杂度的计算比时间复杂度的计算要简单一些。 随着科技的发展，在实践生活中，人们大多数不是很在意空间复杂度。大家都希望效率很高。后期的题目当中我们也经常使用的方法：空间换取时间的方法。

示例1

计算BubbleSort的空间复杂度？

空间复杂度：O(1)

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

 

示例2

计算Fibonacci的空间复杂度？返回斐波那契数列的前n项

空间复杂度：O(N)

long long* Fibonacci(size_t n)
{
	if (n == 0)
		return NULL;
	long long* fibArray = (long long*)malloc((n + 1) * sizeof(long long));
//动态内存开辟的额外的空间N	
    fibArray[0] = 0;
	fibArray[1] = 1;
	for (int i = 2; i <= n; ++i)
	{
		fibArray[i] = fibArray[i - 1] + fibArray[i - 2];
	}
	return fibArray;
}

示例3单独递归

计算阶乘递归Fac的空间复杂度？

递归空间复杂度计算，也是空间的累加，不同于时间，空间可以重复利用。

空间复杂度：O(N)

long long Fac(size_t N)
{
	if (N == 0)
		return 1;
	return Fac(N - 1) * N;
}

 

BT升级双度递归

计算斐波那契递归Fib的时间复杂度？

递归空间复杂度计算，也是空间的累加，不同于时间，空间可以重复利用。

空间是永久存在的，只是开辟给不同的变量，调用完成之后变量会销毁，空间会还给操作系统，又会给新的变量使用。

时间复杂度：O(N)

long long Fib(size_t N)
{
	if (N < 3)
		return 1;
	return Fib(N - 1) + Fib(N - 2);
}

 

 

【这里证明一下空间的重复利用】

#include
void func1()
{
	int a = 0;
	printf("%p\n", &a);
}
void func2()
{
	int b = 0;
	printf("%p\n", &b);
}
int main()
{
	func1();
	func2();
	return 0;
}

思考一下，酒店预订房间的例子，某人预订了一天时间的某个房间，当退房完成之后，这个房间又归属酒店，酒店还可以给其他客人预订使用，这个房间是永久存在的，只是使用的变量不同而已 

答案分析

• 实例1使用了常数个额外空间，所以空间复杂度为 O(1)
• 实例2动态开辟了N个空间，空间复杂度为 O(N)
• 实例3递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N)

常见复杂度对比

✔✔✔✔✔最后，感谢大家的阅读，若有错误和不足，欢迎指正！学习是一个坚持的过程，大家一定要耐心，C++初阶学习完之后，我们就可以去大量的刷题了。现在做好知识理解，整理，练习。

代码---------→【唐棣棣 (TSQXG) - Gitee.com】

联系---------→【邮箱：[email protected]】