【数据结构】时间复杂度和空间复杂度

---

1.算法效率

算法效率是用来衡量一个算法的好坏的，它可以分为时间效率（算法耗费的时间）和空间效率（算法耗费的空间）。时间效率就是时间复杂度，主要衡量一个算法的运行快慢；空间效率就是空间复杂度，主要衡量一个算法运行所需要的额外空间。

---

2.时间复杂度

2.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;//执行N*N次
		}
	}
	for (int k = 0; k < 2 * N ; ++ k)
	{
		++count;//执行了2N次
	}
	int M = 10;
	while (M--)
	{
		++count;//执行了10次
	}
	printf("%d\n", count);
}

总共执行了N^2+2N+1，但是在计算时间复杂度时，不一定要计算精确的执行次数，只需要大概执行次数（量级）。在本例中，但N趋于无穷大时，N ^2起主导作用，而2N+10对结果的影响不大，可以忽略不计，所以执行次数可以近似为N ^2。这些大概执行次数与大O的渐进表示法有关。

2.2大O的渐进表示法（例子）

1. O用来描述函数渐进行为的数学符号。
2. 推导大O阶方法：

（1）用常数1取代运行时间中的所有加法常数。
例子

//计算Func的时间复杂度
void Func(int N)
{
	int count = 0;
	for (int k = 0; k < 100; ++ k)
	{
		++count;
	}
	printf("%d\n", count);
}

算法的基本操作执行了100次，是常数，用O（1）来表示Func的时间复杂度，注意O（1）不是代表1次，而是常数次。

（2）在修改后的运行次数函数中，只保留最高阶项。
例子

// 计算Func的时间复杂度？
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);
}

总共执行了2N+10，最高阶为1阶，常数省略，所以该函数的时间复杂度是O（2N）吗？并不是，是O（N）。为什么？

（3）如果最高阶存在且不是1，则去除与这个项目相乘的常数，得到的结果就是大O阶。当N趋于无穷大时，系数对结果的影响不大，可忽略。

特殊情况
（4）例子

//计算Func的时间复杂度
void Func(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);
}

时间复杂度是O（N+M）。
（5）例子

//while的时间复杂度？
while(*str)
{
	if(*str==character)
	{
		return str;
	}
	++str;
}

这些算法的时间复杂度存在最好、平均、最坏情况。最好情况是任意输入规模的最小运行次数（下界）；平均情况是任意输入规模的期望运行次数；最坏情况是任意输入规模的最大运行次数（上界）。在实际中一般情况关注的是算法的最坏运行情况。
在本例中，最好情况是1次，最坏情况是N次，平均情况是N/2。所以while的时间复杂度是O（N）。
（6）例子

// 计算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（N）（当数组顺序时），最坏情况是O（N^2）（当数组完全逆序时，end = n，循环n-1次，end = n-1，循环n-2次，……，end = 2，循环1次。次数构成等差数列的前n项和，得到大概执行次数就是O（N ^2））。所以时间复杂度是O（N ^2）。
（7）例子

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

最好情况是O（1），直接在中间找到。最坏情况是O（logN），这里省略了底数2，但其他底数不能简写。为什么是logN？如图

注意
a.O（log n ）与O（N）的区别

b.但是二分查找法不实用，因为有前提：数组有序。
（8）例子

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

最好情况是O（1），最坏情况是O（N）。

（9）例子

// 计算斐波那契递归Fib的时间复杂度？
long long Fib(size_t N)
{
	if(N < 3)
	return 1;
	return Fib(N-1) + Fib(N-2);
}

最好情况是O（1），最坏情况是O（2^N）。

---

3.空间复杂度

3.1概念

1. 空间复杂度是用来度量一个算法在运行过程中临时申请的额外的存储空间。它并不计算程序占用多少字节，而是计算程序中变量的个数（或者额外申请的空间）。
2. 同时，它也遵循大O渐进表示法。

话不多说，直接看例子。

3.2例子

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

结果
开辟了3个额外空间，是常数个，所以空间复杂度是O（1）。

疑惑
函数的参数不用算进去吗？不用。空间复杂度计算的是算法在运行过程中额外开辟的内存空间。这三个变量是为了算法的运行而额外开辟的，而函数的参数是数据的提供，不是为了算法的运行而额外创建的。

// 计算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+1个空间，还有1个整形空间，常数项可以省略，所以空间复杂度是O（N）。
疑惑
为什么是申请n+1个空间？不是返回前n项的数组吗？这个存放斐波那契数的数组是从第2 项开始的，第1项存放0。

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

结果
如图，空间复杂度是O（N）。

4. 例5的预备知识

void F1()
{
	int a = 0;
	printf("%p\n", &a);
}
void F2()
{
	int b = 0;
	printf("%p\n", &b);
}
int main()
{
	F1();
	F2();
	return 0;
}

结果

疑惑
为什么a和b的地址会一样呢？因为F1调用结束后，空间被销毁，但销毁的意思是这片空间还给操作系统而不是这片空间不复存在，所以调用F2，F2的空间是在原先F1的空间上建立。其中，F1和F2函数内部结构的相似，都是创建一个变量。所以这两个变量就很合理地创建在同一个位置，地址自然就相同了。

// 计算斐波那契递归Fib的空间复杂度？
long long Fib(size_t N)
{
if(N < 3)
return 1;
return Fib(N-1) + Fib(N-2);
}

结果
O（N）。
为什么

---