👦个人主页：@Weraphael
✍🏻作者简介：目前学习C++和算法ing
✈️专栏：【数据结构】
🐋 希望大家多多支持，咱一起进步！😁
如果文章对你有帮助的话
欢迎 评论💬 点赞👍🏻 收藏 📂 加关注

---

一、时间复杂度的概念

• 算法的时间复杂度是一个函数式，它定量描述了该算法的运行时间。
• 算法中的基本操作的执行次数，为算法的时间复杂度。即找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度

二、时间复杂度的计算

2.1 例题

void Func(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++;
	}
}

【分析】

通过分析，不难可以写出时间复杂度的函数式：

当N = 10时，F(N) = 130
当N = 100时，F(N) = 10210
当N = 1000时，F(N) = 1002010

实际中我们计算时间复杂度时，其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这
里就引入大O的渐进表示法。

2.2 大O的渐进表示法

大O符号（Big O notation）：是用于描述函数渐进行为的数学符号

推导大O阶方法：

1. 用常数1取代运行时间中的所有加法常数，记作：O(1)
2. 只保留最高阶项。假设一个函数式为F(N) = N² + N，记作：O(N²)
3. 如果最高阶项存在且不是1，则去除与这个项目相乘的常数。假设一个函数式为F(N) =2N，记作O(N)

总结：
大O的渐进表示法就是去掉了对结果影响不大的项，简洁明了的表示出了执行次数

另外有些算法的时间复杂度存在最好、平均和最坏情况

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

---

例如：在一个长度为N数组中搜索一个数据x
最好情况：1次就能找到
平均情况：N / 2次找到
最坏情况：需要遍历数组，也就是N次
但在实际中，一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)

【解析2.1例题代码】

使用大O的渐进表示法，只保留最高阶项，所以，时间复杂度为O(N * N)

三、常见时间复杂度计算举例

3.1 实例1

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

【解析】

通过分析，不难可以写出时间复杂度的函数式：

只保留最高阶项以及如果最高阶项存在且不是1，则去除与这个项目相乘的常数。所以，这题的时间复杂度：O(N)

3.2 实例2

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

【分析】

通过分析，不难可以写出时间复杂度的函数式：

由于有两个未知数M和N，则时间复杂度只能为O(M + N)
若题目有明确规定，可以分成三种情况：

• 当M >> N时，则时间复杂度为O(M)
• 当M << N时，则时间复杂度为O(N)
• 当M = N时，则时间复杂度为O(N)或者O(M)

3.3 实例3

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

【分析】

用常数1取代运行时间中的所有加法常数，所以此题的时间复杂度为O(1)

3.4 实例4

char* strchr(const char* str, char c)
{
	while (*str)
	{
		if (*str == c)
		{
			return str;
		}
		str++;
	}
}
//打印指定字字符后面的字符串（包括指定字符）
int main()
{

	char t;
	char a[] = "abcdef";
	scanf("%c",&t);
	char* res = strchr(a,t);
	printf("%s\n",res);
	return 0;
}

【分析】

代码逻辑相当于字符查找，运气最好执行1次，最坏N次，然而时间复杂度一般看最坏情况，时间复杂度为 O(N）

3.5 实例5 — 冒泡排序

void Sort(int arr[],int sz)
{
  
	for (int i = 0; i < sz-1; i++)
	{
		for (int j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
     
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}

【分析】

• 冒泡排序最好情况下：如果元素本来就有序，那么一趟冒泡排序就可以完成排序，也就是N - 1次，因此最好情况的时间复杂度为O(N)
• 最差情况的时间复杂度：如果数据元素本来就是逆序的，第一个数需要比较N-1次，第二个数需要比较N-2次，第三个数需要比较N-3，…直到比较次数为1次时。这一套下来就是一个等差数列，总共就时N * (N - 1) / 2，因此最差的情况的时间复杂度为O(N²)
• 综上，时间复杂度一般看最坏，时间复杂度为O(N²)

3.6 实例6 — 二分查找

int BinarySearch(int* a, int n, int x)
{
	assert(a);
	int begin = 0;
	int end = n;
	while (begin < end)
	{
		int mid = begin + ((end - begin) >> 1);
		if (a[mid] < x)
			begin = mid + 1;
		else if (a[mid] > x)
			end = mid;
		else
			return mid;
	}
	return -1;
}

【分析】

• 二分查找最好的情况：一次二分就找到了，时间复杂度O(1)
• 最坏的情况：一直二分，直到二分只剩下一个数，要么找到，要么找不到。假设N表示数组个数
  
  所以，时间复杂度为O(log N)（注：在时间复杂度中，一般log的底数2可以省略不写）

3.7 实例7 — 递归

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

【分析】

通过上图计算分析发现，基本操作递归了N + 1次，+1影响不大，因此可以省略。所以时间复杂度为O(N)

3.8 实例8 — 斐波那契数列

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

【分析】

通过上图计算分析发现，其递归的次数是一个等比数列的和以及缺少部分的x，F(N) = 2^N-1 + X，因此时间复杂度为O(2^N）

四、空间复杂度

• 空间复杂度也是一个数学表达式，是对一个算法在运算过程中临时占用存储空间大小的量度。
• 空间复杂度计算的是变量的个数，所以空间复杂度计算规则和时间复杂度类似，也使用大O渐进表示法。
• 注意：函数运行时所需要的栈空间在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候申请的额外空间来确定

五、空间复杂度例题

5.1 - 冒泡排序

void BubbleSort(int* a, int n)
{
	for (int end = n; end > 0; end--)
	{
		int flag = 0;
		for (int i = 1; i < end; i++)
		{
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				flag = 1;
			}
		}
		if (flag == 0)
		{
			break;
		}
	}
}

解析：

在上图代码中，一共创建了3个变量，所以，空间复杂度为O(1)

5.2 - 斐波那契

typedef long long LL;
#include <stdlib.h>
LL* Fib(int n)
{
	if (n == 0)
		return 0;
	
	LL* FibArray = (LL*)malloc(sizeof(LL) * (n + 1));
	FibArray[0] = 0;
	FibArray[1] = 1;

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

解析：

在上述代码中，向内存申请了n + 1，所以其空间复杂度为O(n)

5.3 - 递归

typedef long long LL;

LL Fac(int n)
{
	if (n == 0)
	{
		return 1;
	}

	return Fac(n - 1) * n;
}

解析：

如上述代码中，递归一共向内存申请了n - 1个空间，所以，空间复杂度为O(n)

5.4 斐波那契

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

解析：

以左半边为例，当n < 3时，递推停止，所以从Fib(0)开始回归。在回归的过程中，Fib(0)就会销毁，接着回归到Fib(2)，然而Fib(2)又会调用Fib(1)，销毁后又回到Fib(2)。所以，Fib(1)和Fib(2)相当于共用的是同一块空间。细推的话整个过程其实开辟了n + 1个空间。所以空间复杂度为O(n)

四、总结

常见复杂度所耗费的时间从小到大依次是：
O(1)
O(logN)
O(N)
O(NlogN)
O(N²)
O(N³)
O(2^N)