数据结构3

时空复杂度

复杂度是干嘛的

时空复杂度是用来衡量一个算法的好坏的越好的算法所用的时空复杂度越少，分为时间复杂度和空间复杂度

时间复杂度

时间复杂度的概念

在计算机科学中，算法的时间复杂度是一个函数它定量描述了该算法的运行时间。一个算法所花费的时间与其中语句的执行次数成正比，算法中的基本操作的执行次数，为算法的时间复杂度
即：找到某条基本语句与问题规模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++;
}
//前两个嵌套的for循环执行了N^2次，第三个for循环执行了2*N次，第三个while循环执行了10次

所以Func1函数执行的次数就是：F(N) = N^2 + 2*N + 10
实际我们在计算时间复杂度时，我们其实并不一定要精确的执行次数而只要大致的执行次数，而因为在数学中当N趋于正无穷时取确定性的是最高阶项，所以我们使用大O的渐进表示法。

大O的渐进表示法

大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。
推断大O阶方法：
1.用常数1取代运行时间中的所有加法常数。
2.在修改后的运行次数函数中，只保留最高阶项。
3.如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。
上面的Func1函数的时间复杂度用大O的渐进表示后为：O(N^2)
另外有些算法的时间复杂度存在最好、平均和最坏的情况：
最坏情况：任意输入规模的最大运行次数(上界)
平均情况：任意输入规模的期望运行次数
最好情况：任意输入规模的最小运行次数(下界)

一些常见的算法的时间复杂度的例子

//第一个
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中的for循环执行了N次，while循环执行了10次，所以时间复杂度是O(N)。
//第二个
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中的第一个for循环执行了M次，第二个执行了N次，我们不知道M和N的关系所以时间复杂度是O(M+N)。
//第三个
void Func4(int N)
{
 int count = 0;
 for (int k = 0; k < 100; ++ k)
 {
 ++count;
 }
 printf("%d\n", count);
}
//这个算法Func4中的第一个for循环执行了常数次，根据大O的推断，所以是时间复杂度是O(1)。
//第四个
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;
 }
}
//这个是冒泡排序根据等差数列求和公式实际上执行了((N+1)*N)/2次，根据大O的推断，所以时间复杂度是O(N^2)。
//第五个
int BinarySearch(int* a, int n, int x)
{
 assert(a);
 int begin = 0;
 int end = n-1;
 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(log_2N)。
//第六个
long long Fib(size_t N)
{
 if(N < 3)
 return 1;
 
 return Fib(N-1) + Fib(N-2);
}
//是递归实现斐波那契数列，实际操作执行了2^N次，所以时间复杂度是O(2^N)。

空间复杂度

空间复杂度的概念

空间复杂度也是一个数学函数，是对一个算法在运行过程中临时占用储存空间大小的度量。
空间复杂度算的是算法的变量的个数，计算规律基本跟时间复杂度类似，也是用大O渐进表示法
要注意的是空间复杂度的计算主要通过函数在运行过程中显式申请的额外空间来确定。

一些常见的算法的空间复杂度的例子

//第一个
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(1)。
//第二个
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;
}
//这个递推实现斐波那契数列创建了一个数组去保存每一项的数值，数组的长度与想要第几项有关，所以是O(N)。
//第三个
long long Fac(size_t N)
{
 if(N == 0)
 return 1;
 
 return Fac(N-1)*N;
}
//递归计算阶乘，因为每次递归都会调用函数，电泳函数会创建栈帧空间，所以调用了几次就创建了多少空间是O(N)。
//第五个
long long Fib(size_t N)
{
 if(N < 3)
 return 1;
 
 return Fib(N-1) + Fib(N-2);
}
//递归实现斐波那契数列，这个跟上一个一样，每调用一次函数就会开辟临时空间，所以他的空间复杂度是O(N)。

常见的复杂度

最后总结一下常见的复杂度

这个图片可以清晰的看出常见的算法复杂度的难易程度，可以帮助我们自己控制算法的复杂度