【数据结构】算法的复杂度

大家好！今天我们来学习算法的复杂度。

目录

1. 前言

1.1 什么是数据结构？

1.2 什么是算法？

2. 算法效率

3. 时间复杂度

3.1 时间复杂度的概念

3.2 大O的渐进表示法

3.3 常见时间复杂度计算举例

​4. 空间复杂度

4.1 空间复杂度的概念

4.2 常见空间复杂度计算举例

5. 常见复杂度对比

​6. 复杂度练习题

7. 总结

---

1. 前言

1.1 什么是数据结构？

数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的
数据元素的集合。

简单来说，数据结构就是数据在内存中的管理方式。

1.2 什么是算法？

算法(Algorithm):就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。

2. 算法效率

如何衡量一个算法的好坏？

我们引入了算法复杂度这个概念。

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

时间复杂度主要衡量一个算法的运行快慢。

空间复杂度主要衡量一个算法运行所需要的额外空间。

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

3. 时间复杂度

3.1 时间复杂度的概念

时间复杂度的定义：一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。

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

简单来说，时间复杂度是算算法的大概执行次数。跟具体在哪个机器没有关系。

时间复杂度不是算具体的时间，因为具体的时间跟机器的配置有关系。

请计算一下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中++count语句的执行次数。总共有三个循环。

第一个循环是一个二重循环，外循环执行N次，内循环执行N次，++count语句执行N*N次。

第二个循环中，++count语句执行2*N次。

 第三个循环中，因为M=10，执行了M次，也就是10次，++count语句执行了10次。

所以Func1中++count语句共执行了N^2+2*N+10次。

因此我们得到了时间复杂度的函数关系式：

F(N)=N^2+2*N+10

我们发现F(N)的值主要取决于N^2这一项。

所以我们在算时间复杂度时要抓大头，取决定性结果那一项。

3.2 大O的渐进表示法

在实际计算时间复杂度时，不一定要计算精确的执行次数，而只需要大概执行次数，所以我们使用大O的渐进表示法。

大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。
推导大O阶方法：

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

（去掉系数）

使用大O的渐进表示法以后，Func1的时间复杂度为O(N^2)：
N = 10            F(N) = 100
N = 100          F(N) = 10000
N = 1000        F(N) = 1000000
通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。（本质计算的是属于哪个量级）

另外有些算法的时间复杂度存在最好、平均和最坏情况：
最坏情况：任意输入规模的最大运行次数(上界)
平均情况：任意输入规模的期望运行次数
最好情况：任意输入规模的最小运行次数(下界)
例如：在一个长度为N数组中搜索一个数据x
最好情况：1次找到
最坏情况：N次找到
平均情况：N/2次找到
在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据（遍历数组）的时间复杂度为O(N)。

时间复杂度计算时，是一个稳健保守预期。

3.3 常见时间复杂度计算举例

实例1：计算Func2的时间复杂度？

void Func2(int N)
{
    int count = 0;
    for (int k = 0; k < 2 * N; ++k)
    {
        ++count;
    }
    int M = 10;
    while (M--)
    {
        ++count;
    }
    printf("%d\n", count);
}

我们发现Func2()函数中有两个循环，第一个循环进行2*N次，第二个循环进行10次（M=10），

所以得到精确的时间复杂度的函数关系式:F(N)=2*N+10

根据大O的渐进表示法，我们可以把与最高阶项相乘的系数2和加法常数10去掉，从而得到Func2()的时间复杂度为O(N)。

实例2：计算Func3的时间复杂度？

void Func3(int N, int M)
{
	int count = 0;
	for (int k = 0; k < M; ++k)
	{
		++count;
	}
	for (int k = 0; k < N; ++k)
	{
		++count;
	}
	printf("%d\n", count);
}

我们发现Func3()函数中有两个循环，第一个循环进行了M次，第二个循环进行了N次。所以总共进行了M+N次。

但是我们并不知道M和N的大小，无法判断M和N谁对结果的影响大，所以我们要分情况讨论：

（1）如果M远大于N，我们认为时间复杂度是O(M)

（2）如果N远大于M，我们认为时间复杂度是O(N）

（3）如果M和N一样大或者大小相近，我们认为时间复杂度是O(N)或者O(M)

（相当于是2M或者2N，但是要忽略最高阶项系数）

注意：一般情况下表示时间复杂度的未知数我们都用N表示，但是如M或者K等也可以表示。

实例3：计算Func4的时间复杂度？

void Func4(int N)
{
	int count = 0;
	for (int k = 0; k < 100; ++k)
	{
		++count;
	}
	printf("%d\n", count);
}

Func4()函数中给我们的并不是一个未知数，而是一个常数100。函数有一个循环，执行了100次。

可能有小伙伴会认为这里的时间复杂度是O(100)，但事实上并不是。我们根据大O的渐进表示法的第1条——用常数1取代运行时间中的所有加法常数。所以这里的时间复杂度是O(1)。

注意：O(1)并不是代表一次，而是代表常数次。

因为cpu足够快，所以无论k是1000还是1亿也是O(1)。但是写常数也有上限，有符号21亿，无符号42亿。

实例4：计算strchr的时间复杂度？

const char * strchr ( const char * str, int character );

strchr是一个字符查找函数，简单来说，就是一个实现在字符数组中查找相应字符的函数。

具体过程和分析如下：

 因为时间复杂度是一个稳健保守的悲观预期，所以我们要取最坏的情况即N次（N是*str的长度）。所以函数strchr()的时间复杂度为O(N)。

实例5：计算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;
	}
}

显而易见，这是一个冒泡排序的过程。

当外层循环中end=n时，内层循环进行了n-1次。

当外层循环中end=n-1时，内层循环进行了n-2次。

当外层循环中end=n-2时，内层循环进行了n-3次。

......

当外层循环中end=3时，内层循环进行了2次。

当外层循环中end=2时，内层循环进行了1次。

当外层循环中end=1时，内层循环进行了0次。

我们可以发现总的执行次数为1+2+3+...+（n-3）+(n-2)+(n-1) 

是一个等差数列的求和，我们使用等差数列求和公式 Sn=(a1+an)×n÷2  即（首项+尾项)×项数÷2

Sn=[(1+(n-1)]x(n-1)/2=n*(n-1)/2

所以冒泡排序的时间复杂度是O(N^2)

实例6：计算BinarySearch的时间复杂度？

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

显而易见，这是一个二分查找。

二分查找也叫折半查找，每次通过比较a[mid]与想知道的数x的大小，不断将区间减半，直到区间变成1。

具体过程和分析如下：

 

 我们分析N/2/....../2/2=1这个式子，我们假设最坏情况下查找了x次，即等号左边的N除了x个2，我们将等号左右两边同乘x个2，那么等号左边即为N，右边的式子从1变成了2^x。

我们得到关系2^x=N，根据对数和指数的关系 ，我们得到x=log2N

因为对数在文本中不好写，支持一些展示公式的编辑器才方便。因此我们将log2N简写成logN。

（但是只有底数为2，即log2N可以把2省略，其它的底数要写出来）。

所以二分查找的时间复杂度为O(logN)。

当我们把14亿人的身份号放到数组排序，二分查找最坏只要31次就能找到!!!

我们可以发现二分查找的效率是非常高的！

实例7：计算阶乘递归Fac的时间复杂度？

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

函数是向下深度递归的：

严格来说从N到0有N+1次调用，因此这个函数的时间复杂度是O(N)。

递归算法的时间复杂度是多次递归调用的次数累加。

变式：计算如下函数的时间复杂度？

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

	for (size_t i = 0; i < N; ++i)
	{
		//...
	}

	return Fac(N - 1) * N;
}

第一次调用时循环执行了N次，每次调用N都会减1，第二次调用时执行N-1次，第三次调用执行N-2次...，N=2时执行2次，N=1时执行1次。

也是一个的等差数列的求和。时间复杂度为O(N^2)。

实例8：计算斐波那契递归Fib的时间复杂度?

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

 事实上越往右边的递归应该越先结束，实际上面的递归应该是如下的图形(阴影表示缺失部分):

但是缺失部分的量级是远小于整体的。

所以我们认为递归的斐波那契函数的时间复杂度是O(2^N-1）。 

总结：

通过上面多个例子，我们发现时间复杂度的计算不应该单纯看代码，更应该看重思想。

4. 空间复杂度

4.1 空间复杂度的概念

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

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

在函数内只额外定义了end、exchange、i三个变量，也就是额外开辟了3个空间。也就是额外开辟了常数个空间，所以这里的空间复杂度为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;
}

使用了malloc函数动态开辟了n+1个空间，所以空间复杂度为O(N)。

实例3：计算Fibonacci的空间复杂度？

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

每次递归调用时都要建立栈帧，每个栈帧创建常数个变量（也就是每个栈帧要开常数个额外空间），可以认为每个栈帧是O(1)，有n个栈帧，那么空间复杂度就是O(N）。

实例4：计算如下函数的空间复杂度？

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

这个函数的空间复杂度是O(N)。

因为函数深度往下递归时调用总共建立了n个栈帧，回溯时栈帧销毁 。栈帧销毁时，这块空间还是在的。内存的释放和销毁只是把它的使用权还给了操作系统，Fib(1)和Fib(0)共用一块空间。

右边是重复利用左边的空间。就好比我去宾馆开了个房间，这个时候使用权是我的，但退房后这个房间仍然在，但这时房间的使用权就是下一个人的，所以额外最多用了n个空间。

总结：

时间是可以累积的，一去不复返，空间是可以重复利用的。

5. 常见复杂度对比

一般算法的常见复杂度如下：

电脑一般一秒可以运行10^8的运算次数，就是循环跑10^8个的速度。

复杂度对应代码的速度快慢。

越平稳在量更大的时候优势越大。
 

6. 复杂度练习题

1. 分析以下函数的时间复杂度？

void fun(int n) {
	int i = 1;
	while (i <= n)
		i = i * 2;
}

A .O(n)                    B .O(n^2)                    C .O(nlogn)                    D .O(logn)

解析：此函数有一个循环，但是循环没有被执行n次，i每次都是2倍进行递增，所以循环只会被执行log2(n)次。故选D。

2. 分析以下程序的时间复杂度？

for (int i = 0; i < n; i++)
	for (int j = 0; j < n; j++)
		a[i][j] = i * j;

A .O(n)                    B .O(n^2)                    C .O(nlogn)                    D .O(logn)

解析：程序有两次循环，每个循环都有n次操作，所以时间复杂度为n^2。故选B。

3. 下面算法的时间复杂度是（   ）

int f(unsigned int n) {
	if (n == 0 || n == 1)
		return 1;
	else
		return n * f(n - 1);
}

A .O(n)                    B .O(n^2)                    C .O(nlogn)                    D .O(logn)

 解析：此函数会被递归调用n - 1次，每次操作都是一次，所以时间复杂度为n。故选A。

4. 给定一个整数sum，从有N个有序元素的数组中寻找元素a，b，使得a+b的结果最接近sum，最快的平均时间复杂度是（   ）

A .O(n)                    B .O(n^2)                    C .O(nlogn)                    D .O(logn)

解析：此题目中，数组元素有序，所以a,b两个数可以分别从开始和结尾处开始搜，根据首尾元素的和是否大于sum,决定搜索的移动，整个数组被搜索一遍，就可以得到结果，所以最好时间复杂度为n。故选A。

5. 设某算法的递推公式是T(n)=T(n-1)+n，T(0)=1，则求该算法中第n项的时间复杂度为（）

A .O(n)                    B .O(n^2)                    C .O(nlogn)                    D .O(logn)

解析：

T(n)

=T(n-1)+n

=T(n-2)+(n-1)+n

=T(n-3)+(n-2)+(n-1)+n

...

=T(0)+1+2+...+(n-2)+(n-1)+n

=1+1+2+...+(n-2)+(n-1)+n

从递推公式中可以看到，第n项的值需要从n-1开始递归，一直递归到0次结束，共递归了n-1次

所以时间复杂度为n。故选A

6. 分析以下函数的空间复杂度（   ）

int** fun(int n) {
	int** s = (int**)malloc(n * sizeof(int*));
	while (n--)
		s[n] = (int*)malloc(n * sizeof(int));
	return s;
}

A .O(n)                    B .O(n^2)                    C .O(1)                    D .O(nlogn)

解析：此处开辟的是一个二维数组，数组有n行，每行分别有1,2,3,...n列，所以是n(n + 1)/2个元素空间，空间复杂度为n^2。故选B

7. 如果一个函数的内部中只定义了一个二维数组a[3][6]，请问这个函数的空间复杂度为（   )

A .O(n)                    B .O(n^2)                    C .O(1)                    D .O(m*n)

 解析：函数内部数组的大小是固定的，不论函数运行多少次，所需空间都是固定大小的，因此空间复杂度为O(1)。故选C。

7. 总结

到这里，我们就介绍完了算法的时间复杂度和空间复杂度。有什么问题欢迎在评论区讨论。如果觉得文章有什么不足之处，可以在评论区留言。如果喜欢我的文章，可以点赞收藏哦！