＜数据结构＞——复杂度

本文内容较多，需要耐心，详细的介绍了复杂度这一概念，附有大量的案例助于理解。若能耐心看完，对复杂度的理解基本上没有问题

在计算机科学中，复杂度分为时间复杂度和空间复杂度。

复杂度的计算都遵循大O的渐进表示法，常常通过牺牲空间来换取时间

---

时间复杂度

定义：在计算机科学中，算法的时间复杂度是一个函数式T(N)，这里的函数式类似于数学中的f(x),注意区别于代码中的函数。T(N)定量的描述了该算法的运行时间，时间复杂度是衡量程序的时间效率，复杂度越低，运行效率越高。

1. 因为程序的运行时间和编译环境、运行机器的配置都有关系，比如一个算法程序，用一个老编译器和一个新编译器编译，在同样的机器下运行时间都可能会不同。
2. 同一个算法程序，用一个老低配置和新高配置的机器，运行时间也不同。
3. 并且时间只能程序写好后测试，不能写程序前通过理论思想计算评估。

那么算法的时间复杂度T(N)到底是什么呢？这个T(N)函数式计算了程序的执行次数。那我们通过程序代码或则理论思想计算出程序的执行次数的函数式T(N)，假设每句指令执行时间基本相同（实际是有偏差的，但微乎其微），那么执行次数和运行时间就是成正相关，这样就脱离了具体的编译运行环境。执行次数就可以代表程序时间效率的优劣。比如解决一个问题的算法a程序T(N)=N，算法b程序T(N)=N^2，那么算法a的效率一定优于算法b。

---

空间复杂度

1. 空间复杂度也是一个数学表达式，是对一个算法在运行过程中因为算法需要额外临时开辟的空间。空间复杂度不是程序占用了多少bytes的空间，因为常规情况每个对象的大小差异不会很大，所以空间复杂度计算的是变量的个数，比如创建了一个大小为N的数组，那么空间复杂度为O(N)。
2. 空间复杂度计算规则基本和时间复杂度类似，也是用大O渐进表示法。

注意：函数运行时所需的栈空间（形参，局部变量、一些寄存器信息等）在编译期间就已经确定好了，因此空间复杂度主要通过函数在运行时显示申请的额外空间来确定

---

 大O的渐进表示法

大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。大O通常是关注最差的情况

曲线越陡峭，程序效率越低

---

推导大O阶规则：

1.时间复杂度函数式T(N)中，只保留最高阶项，去掉那些低阶项，因为当N不断变大时，低阶项对结果的影响越来越小，当N无穷大时，就可以忽略不计了。

2.如果最高项系数存在且不为1，则去除这个项目的常数系数，因为当N不断变大，这个系数对结果的影响越来越小，当N无穷大时，就可以忽略不计了（eg：T(N)=2k^2,则表示O(K^2)）。

3.T(N)中如果没有相关的式子，只有常数项（eg：T(N)=100，则表示为O(1)）

---

计算时间复杂度的若干案例

示例一

计算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++;
	}
}

此时T(N)=N^2+2N+10

根据第一条规则得出时间复杂度为O(N^2)

示例二

计算Func2的时间复杂度

void Func2(int N)
{
	int count = 0;
	
	for (int k = 0; k < 2 * N; k++)
	{
		count++;

	}
	int m = 10;
	while (m--)
	{
		count++;
	}
}

T(N)=2N+10

根据规则一与规则二，Func2的时间复杂度为O(N)

示例三

计算Func3的时间复杂度

void Func3(int N，int M)
{
	int count = 0;
	for (int i = 0; i < N; i++)
	{
			count++;
	}
	for (int k = 0; k < M; k++)
	{
		count++;

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

T(N)=M+N  ——>  O(M+N)，

若M>>N，则时间复杂度为O(M)

若M<<N，则时间复杂度为O(N)

若M==N(近似相等），则时间复杂度为O(M+N)

示例四

计算Func4的时间复杂度

void Func4()
{
	int count = 0;
	for (int k = 0; k < 100; k++)
	{
		count++;

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

T(N)=100，根据规则三，时间复杂度为O(1)

示例五

计算strchr的时间复杂度

const char* strchr(const char* str, int character)
{
	const char* p_begin = str;
	while (*p_begin != character)
	{
		if (*p_begin == '\0')
			return NULL;
		p_begin++;
	}
	return p_begin;
}

T(N)取决于在字符串中查找的位置，对于时间复杂度

最好情况，第一个位置就查找到，则O(1)

平均情况，在中间位置查找到，则O(N/2)

最坏情况，在最后一个位置查找到，则O(N)

示例六

一个有关对数的时间复杂度的计算

void Func5(int n)
{
	int cnt = 1;
	while (cnt < n)
	{
		cnt *= 2;

	}
}

执行次数	cnt的值
1	2=2^1
2	4=2^2
3	8=2^3
4	16=2^4
……	……
x	2^x

当n=10，2^x=n,X=，因为2^x<10，x=4；所以时间复杂度可以看做为O(x)，即O()

因为当n接近无穷大时，底数的大小对结果的影响不大。因此，一般情况下不管底数是多少都可以省略不写，即可以表示成O()。

一个递归的时间复杂度的计算

运行一次即为1，总共递归了n次，1*n=n，即时间复杂度为O(N)

计算空间复杂度的案例

void BubbleSort(int* a, int n)
{
	int t = 0;
	for (int i = 0; i < n - 1; i++)//1
	{
		int flag = 0;//1
		for (int j = 0; j < n - 1 - i; j++)//1
		{
			if (a[j] > a[j + 1])
			{
				t = a[j];
				a[j] = a[j + 1];
				a[j + 1] = t;
				flag = 1;

			}
		}
		if (flag == 0)
			break;
	}
}

在这个冒泡排序函数中，a是一个数组的指针，在此函数运行之前就已开辟好空间，所以在此函数中实际上就只定义三个变量，开辟三个空间，T(N)=3。根据大O的规则三，空间复杂度为O(1)。