手把手教你拿下时间空间复杂度，（包教包会）【上】

前言

---

这里是双非程序猿为大家带来的小技术分享,欢迎来到数据结构第一站——时间复杂度，这篇文章将会以多个例子讲解，并手把手教你教学，包教包会。

初学者刚学完c语言基本语法来学习数据结构的时候、或者后期学习的时候，普遍会将直接将时间复杂度与空间复杂度的概念忽略的（没错，就是我！😂）。
因为毕竟他和我们的编程似乎是没有什么直接的联系的。这样学习是不长远的，因为学到后面你会发现，你始终绕不开这两个复杂度的。
以严蔚敏老师的《数据结构与算法》这本教材来看的话，你每学完一个结构，教材一定会带你分析一遍时间复杂度与空间复杂度。由此可见其重要性。

---

来吧一起加油，拿下时间复杂度！

一、复杂度的意义

（如果觉得这段有点啰嗦的话，就直接看下一点吧）

算法效率分为两种：时间效率、空间效率。 时间效率被称为时间复杂度，空间效率被称为空间复杂度。时间复杂度主要衡量的是一个算法的运行速度，空间复杂度衡量的是一个算法所需的额外空间。

在计算机发展的初期，计算机的内存空间很小，所以我们十分看中算法的空间复杂度。但经过计算机行业的迅速发展，计算机的空间已经越来越大了，空间也就越来越不值钱了，因此我们现在更看中的是时间复杂度。

二、时间复杂度的概念

时间复杂度的定义为：在计算机科学中，时间复杂性，又称时间复杂度，算法的时间复杂度是一个函数，它定性描述该算法的运行时间。
那我们要研究一个程序的时间复杂度是不是直接将程序上机跑一遍，记录他运行的时间就行了呢？这样是不行的，因为不同的电脑所带着的硬件不同，这会直接影响到程序的运行时间，因此这种方法不具有普遍性。

我们在估量一个算法的时间复杂度的方法其实很简单，计算它的执行次数。

举个例子

#indlude<stdio.h>
int main()
{
	printf("Hollow World!");
	return 0;
}

这里面的printf（“Hollow World！”）; 与return 0；就相当于这个程序执行了两次。而两次就是这个程序的时间复杂度了吗？卖个小关子（千万别不往下看了哈😆，马上就有干货了）。

三、计算时间复杂度

先用一个例子来算一下

void Fun(int N)//该函数没有任何意义，是方便理解写的
{
	for(int i=0;i<N;i++)//嵌套循环在这里执行了N*N次。
		for（int j=0;j<N;j++）
			cons++;//这是全局变量。
	for(int i=0;i<2*N;i++)//在这里执行了2*N次。
		cons++;
	for(int i=0;i<10;i++)//在这里执行了10次。
		cons++;
}

为了更好的展示主要执行次数，这个函数我们可以粗略认为它的时间复杂度的式子O=N²+2N+10次（为什么可以粗略认为会在下文解释，现在先将就一下哈哈），在这里我们只统计了主要的执行次数。然而时间复杂度其实是一种估算，是由影响时间复杂度最大项决定的，在这里影响最大的项为N²。原因如下：

N的值	N²的值	O的值
1	1	13
10	100	130
100	10000	10210
1000	1000000	1002010

随N值的变化对时间复杂度影响最大因数其实是N²，所以时间复杂度为O（N²）。
时间复杂度的标准表示法为O（），（）里面装的就是式子中最高阶。

大O符号：适用于描述函数中渐进行为的表示法。（实在理解不了的话也没关系）

上干货，推导大O阶的方法方法：

1. 用常数1代替式中所有常数。
2. 在修改过的式子中保留最高阶。
3. 若最高阶为常数结果就是1。
4. 若最高阶不是常数的话结果就是这个最高阶。

接下来就是计算时间复杂度的几种情况。

四、例题

毫不夸张的说，接下来几个例子可以带你拿下时间复杂度

情况一

void Fun(int N)
{
	int count=0;
	for(int K=0;K<2*N;k++)//执行2N次
		count++;
	for(int M=10;M>0;M--)//执行10次
		count++;
}

在这里我们得出一个式子O=2N+10；

• 用常数1代替式中所有常数。—— O=N+1。
• 在修改过的式子中保留最高阶 ——O=N。
• 得出结果O（N）。

情况二

那么这一段的时间复杂度呢？这一段就有点不一样了，不说别人，反正我是蒙在鼓里很久才知道是这样算的 😂。

void Fun2(int N,int M)
{
   int count=0;
   for(int k=0;k<N;k++)//执行次数为N
   	const++;
   for(int k=0;k<M;k++)//执行次数为M
   	const++;
}

我们得出一个式子：O=N+M，跟我一起算。

• 用常数1代替式中所有常数。—— O=N+M。
• 在修改过的式子中保留最高阶。——O=N+M。
• 最高阶不为常数—— O（N+M）。

一般情况下时间复杂度为O（N+M），除非有特殊说明。
（1）.当N远大于M时,时间复杂度为O（N）。
（2）.当M远大于N时，时间复杂度为O（M）。
（3）.当M与N差不多大的时候，O=2M，常数替换为1，保留最高阶——O（N）或 O（M）。

是不是干货满满，😎，关注我持续输出高质量博客。

情况三

void Fun3（int N）//这里的N对我们的时间复杂度没有影响
{
	int count=0;
	for(int k=0;k<100;k++)//在此处执行了100次
		count++;
}

我们得出一个式子：O=100.

• 用常数1代替式中所有常数。—— O=1。
• 保留最高阶。—— O=1。
• 最高阶为常数，得出结果O（1）。

注意这里的1不是只执行1次的意思，而是最高阶为常数的意思。

情况四

这是一段在一个字符串里找字符的代码

int Fun4(char s,char a[N])//N为已知数
{
	int i;
	for(i=0;i<N;i++)
		if(a[i]==s)
			break;
	return i;
}

这里的时间复杂度是多少呢？和上面不同的是，在这里我的执行次数可以是1，可以是5,，也可以是N。那这样我们的时间复杂度到底是多少呢？先上干货：

• 有些算法的时间复杂度存在最好、平均和最坏的情况
• 最坏情况：操作执行的最大次数（上界）。
• 平均情况：操作执行的期望运行次数。
• 最好情况：操作执行的最小次数。

在这里查找次数的
最好情况为，1次。
平均情况为，N/2次。
最坏情况为，N次。

在这里时间复杂度应该取最坏情况O（N），原因是：虽然这样选不会那么精确，但绝对不会错。

情况五

void Fun5(int a[N])//冒泡排序
{
	int temp;
	for(int end=N;end>0;end--)
	{
		for(int j=0;j<end-1;j++)
			{
				if(a[j]>a[j+1])
				{
					temp=a[j];
					a[j]=a[j+1];
					a[j+1]=temp;
				}
			}
	}
}

很多朋友看到有两个循环嵌套，应该就会想当然的得出时间复杂度就是O(N²),答案确实没错，但你真的知道这是怎么得出来的吗？而且并不是每个循环嵌套的结构时间复杂度都是O（N²）。

冒泡排序的思想就是把最大（或最小）的数不断后面或前面排。为了加深理解，我专门找了一张动态图：

了解了冒泡排序的同学不难想出，这个冒泡排序比较次数=N-1+N-2+N-3+N-4…+2+1=[（N+1）*N]/2（等差数列求和公式）。得出式子O=[（N+1）*N]/2。

1. 常数变为1——O=（N+1）*N。
2. 保留最高阶——O=N²。
3. 最高阶不为常数，得出结果O（N²）。

不了解冒泡排序的同学可以私信我，包教包会。这么有诚意的博主就关注一个叭。

这五个例子一定要亲手算一遍，加深印象。相信在算完这五个例子后，程序猿们已经知道如何计算时间复杂度了。不过还有几个没这么常用的情况，我直接放在下面了，顺便做个比较。

O(1) < O(logn) < O(n) < O(nlogn) < O(n²) < O(n³) < O(nⁿ)

抱歉在这里才解释，在上文我们之所以可以粗略的得出一个个式子的原因是，我们省略的执行次数是类似于“int count；”这样的操作，而这步操作的次数为1，对我们的时间复杂度O（）不会产生影响

结语

我是大一新生一个，计算机小菜鸡一个。显然与许多大神不同的是，我的码龄还仅仅不到一年，现在尚处于一个知识的原始积累阶段。
但正因为我有一个和许多小白一样的水平，能使我更明白小白们的一些疑难杂症，从而对症下药。希望与大家一同进步。大学生博主，可以点点关注支持一下吗，或者免费的赞也可以鼓励鼓励我的哦，我会继续推出高质量博客，写的有问题的话，欢迎在评论区喷我😊。