算法之【时间复杂度】与【空间复杂度】

一、算法

1、算法定义

2、两种算法的比较

3、算法的特性

4、算法设计的要求

二、算法的复杂度

1、时间复杂度

1.1定义

1.2大O的渐近表示法

1.3推导大O阶方法

1.4最坏情况与平均情况

1.5常见的时间复杂度计算示例

🍂常数阶：

🍂线性阶：

🍂对数阶：

🍂平方阶：

2、空间复杂度

一、算法

1、算法定义

算法就是定义良好的计算过程，它取一个或一组的值为输入，并产生出一个或一组的值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。概括起来就是数据结构是在内存当中存储、管理数据；算法是对各种数据进行处理，怎么处理就看我们自己的需求了。

2、两种算法的比较

现在要求写一个求1+2+3+······+100结果的程序，大多数人会马上写出下面的C语言代码：

#include <stdio.h>
int main()
{
	int i;
	int sum = 0;
	int  n = 100;
	for (i = 1; i <= 100; i++)
	{
		sum += i;
	}
	printf("%d\n", sum);

	return 0;
}

这是最简单的计算机程序之一，它就是一种算法，但这种算法是最高效的吗？

这个时候，我们就得将伟大的数学家高斯的童年故事拿来说一遍。据说18世纪生于德国小村庄的高斯，上小学的一天，课堂很乱，老师就非常生气，于是在放学时，就要求每个学生都计算1+2+···+100的结果，谁先算出来谁先回家。天才当然不会被这样的问题难倒，高斯很快就得出了答案，是5050。老师非常惊讶，因为他自己想必也是通过1+2=3，3+3=6，······4950+100=5050这样算出来的，也算了很久很久。可是，眼前这个少年，一个上小学的孩子，为何可以这么快的得出结果？高斯解释道：

sum = 1 + 2 + 3 + ... + 99 + 100
sum = 100 + 99 + 98 + ... + 2 + 1
2 * sum = 100 + 101 + 101 + ... + 101 + 101 (共100个)

所以sum = 5050

用程序实现如下：

#include <stdio.h>
int main()
{
	int sum = 0;
	int n = 100;
	sum = (1 + n) * n / 2;
	printf("%d\n", sum);

	return 0;
}

高斯的方法相当于一种求等差数列的算法，不仅仅可以用于1加到100，就是加到1千，1万，1亿，也就是瞬间之事。但如果用第一种挨个加的程序，显然计算机要循环1千，1万，1亿次的加法运算。

3、算法的特性

算法具有五个基本特性：输入、输出、有穷性、确定性和可行性。

🍂输入输出：

算法具有零个或多个输入，至少有一个或多个输出。

🍂有穷性：

指算法在执行有限的步骤之后，自动结束而不会出现无限循环，并且每一个步骤在可接受的时间内完成。

🍂确定性：

算法的每一步骤都具有确定的含义，不会出现二义性。

🍂可行性：

算法的每一步都必须是可行的，也就是说，每一步都能够通过执行有限次数完成。

4、算法设计的要求

好的算法设计有四个要求：正确性、可读性、健壮性、时间效率高和存储量低。

🌻正确性：

算法的正确性是指算法至少应该具有输入、输出和加工处理无歧义性，能正确反映问题的需求，能够得到问题的正确答案。

🌻可读性：

算法设计的另一目的是为了方便阅读、理解和交流。

🌻健壮性：

当输入数据不合法时，算法也能做出相关处理，而不是产生异常或莫名其妙的结果。

🌻时间效率高和存储量低：

时间效率指的是算法的执行时间，执行时间短的算法效率高，执行时间长的效率低；存储量需求指的是算法在执行过程中需要的最大存储间，主要指算法程序运行时所占用的内存或外部硬盘存储空间。

二、算法的复杂度

算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源。因此衡量一个算法的好坏，一般是从时间和空间两个角度来衡量的，即时间复杂度和空间复杂度。

时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。在计算机发展的早期，计算机的存储容量很小，所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要在特别关注一个算法的空间复杂度。

1、时间复杂度

1.1定义

在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是都可以上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例。算法中的基本操作的执行次数，为算法的时间复杂度。即找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度。

1.2大O的渐近表示法

我们先来看一段代码，请计算一下Func1中++count语句总共执行了多少次？

void Func1(int N)
{
	int count = 0;
	for (int i = 0; i < N; ++i)
	{
		for (int j = 0; j < N; ++j)
		{
			++count;
		}
	}
	for (int k = 0; k < 2 * N; ++k)
	{
		++count;
	}
	int M = 10;
	while (M--)
	{
		++count;
	}

printf("%d\n", count);
}

Func1 执行的基本操作次数：F(N) = N^2 + 2*N + 10

实际中我们计算时间复杂度时，其实并不一定要计算精确的执行次数，而只需要计算大概执行次数，那么这里我们使用大O的渐进表示法。
大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。

1.3推导大O阶方法

用常数1取代运行时间中的所有加法常数。
在修改后的运行次数函数中，只保留最高阶项。
如果最高阶项存在且其系数不是1，则去除与这个项相乘的系数。

得到的结果就是大O阶。

🎈上面的代码使用大O渐进法以后，Func1的时间复杂度为：O(N^2)

1.4最坏情况与平均情况

通过上面的代码示例我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。另外有些算法的时间复杂度存在最好、平均和最坏情况：

🍁最坏情况：任意输入规模的最大运行次数(上界)
🍁平均情况：任意输入规模的期望运行次数
🍁最好情况：任意输入规模的最小运行次数(下界)

例如：我们在一个长度为N的数组中查找某个数字：

🍁最好情况：1次找到
🍁最坏情况：N次找到
🍁平均情况：N/2次找到

在实际中一般在没有特殊说明的情况下，关注的都是算法的最坏运行情况，即最坏时间复杂度，所以数组中搜索数据时间复杂度为O(N)。

1.5常见的时间复杂度计算示例

🍂常数阶：

int sum = 0，n = 100;//执行一次
sum = (1 + n) * n / 2;//执行一次
printf("%d\n", sum);//执行一次

这个算法的运行次数函数是f(n) = 3。根据我们推导大O阶的方法，第一步就是把常数项3改为1。在保留最高项阶时发现，它根本没有最高阶项，所以这个算法的时间复杂度为O(1)。

另外，我们试想一下，如果这个算法当中的语句sum = (1 + n) * n / 2有10句，即：

int sum = 0, n = 100;//执行1次
sum = (1 + n) * n / 2;//执行第1次
sum = (1 + n) * n / 2;//执行第2次
sum = (1 + n) * n / 2;//执行第3次
sum = (1 + n) * n / 2;//执行第4次
sum = (1 + n) * n / 2;//执行第5次
sum = (1 + n) * n / 2;//执行第6次
sum = (1 + n) * n / 2;//执行第7次
sum = (1 + n) * n / 2;//执行第8次
sum = (1 + n) * n / 2;//执行第9次
sum = (1 + n) * n / 2;//执行第10次
printf("%d\n", sum);//执行1次

事实上无论n为多少，上面的两段代码就是3次执行和12次执行的差异。这种与问题的大小（n的大小）无关，执行时间恒定的算法，我们称之为具有O(1)的时间复杂度，又叫常数阶。

注意：不管这个常数是多少，我们都记作O(1)，而不能是O(3)、O(12)等其它任何数字。

🍂线性阶：

线性阶的循环结构会复杂很多。要确定某个算法的阶次，我们常常需要确定某个特定语句或某个语句集运行的次数。因此，我们要分析算法的复杂度，关键就是要分析循环结构的运行情况。

int i;
for (i = 0; i < n; i++)
{

}

上面这段代码，循环体中的代码需要执行n次，所以它的时间复杂度就为O(n)。

🍂对数阶：

int count = 1;
while (count < n)
{
	count = count * 2;
}

上面这段代码，由于每次count乘以2之后，就距离n更近了一分。也就是说，有多少个2相乘后大于n，则会退出循环。由2^x=n得到x=log以2为底的n次方。所以这个循环的时间复杂度为O(logn)。

🍂平方阶：

int i, j;
for (i = 0; i < n; i++)
{
	for (j = 0; j < n; j++)
	{

	}
}

上面这段代码是一个嵌套循环，它的内层循环时间复杂度为O(n)；而对于外层的循环，不过是内部这个时间复杂度为O(n)的语句，再循环n次。所以这段代码的时间复杂度为O(n^2)。

如果外循环的循环次数改为了m，时间复杂度就变为O(m*n)。

int i, j;
for (i = 0; i < n; i++)
{
	for (j = 0; j < m; j++)
	{

	}
}

🌲所以我们可以总结得出，循环的时间复杂度等于循环体的复杂度乘以该循环的运行次数。

那么下面这个循环嵌套，它的时间复杂度是多少呢？

int i, j;
for (i = 0; i < n; i++)
{
	for (j = i; j < n; j++)
	{

	}
}

由于当i = 0时，内循环执行了n次，当i = 1时执行了n-1次，······当i = n - 1时，执行了1次。所以总的执行次数为：
n + (n-1) + (n-2) +···+1 = n(n+1)/2 = n^2/2 + n/2

用我们推导大O阶的方法，第一条，没有加法常数不予考虑；第二条，只保留最高阶项，因此保留n^2/2；第三条，去除与这个项相乘的常数，也就是去除1/2，最终这段代码的时间复杂度为O(n^2)。

🍒常见的时间复杂度如下表所示：

🍒常用的时间复杂度所耗费的时间从小到大依次是：

O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)

2、空间复杂度

空间复杂度也是一个数学表达式，是一个算法在运行过程中临时占用存储空间大小的量度。
空间复杂度不是程序占用了多少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(1) 。

🌴实例2：

// 计算Fibonacci的空间复杂度？
// 返回斐波那契数列的前n项
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;
}

上面这段代码动态开辟了N个空间，空间复杂度为 O(N) 。

🌴实例3：

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

上面这段代码递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间，所以空间复杂度为O(N) 。