＜数据结构＞NO1.算法的时空复杂度

算法效率

算法是一个被设计好的，计算机可实施的有限步骤或次序，包含一系列清晰的指令。
一个算法需要在有限的时间和空间内被执行，衡量算法效率高低就是通过执行算法所需要的时间和空间

算法复杂度

算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源 。因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。

时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。

---

时间复杂度

时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是在不同的环境下，执行的速度又有差异，因此有了时间复杂度这个分析方式。一个算法所花费的时间与其中所有语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。
更加通用的时间复杂度表示方法为[ 大O符号表示法 ]，即T(n)=O(f(n))，f(n)表示每行代码的执行次数之和，大O表示正比关系。这个公式的全称为：算法的渐进时间复杂度

常见的时间复杂度有

• O(1)
• O(logn)
• O(n)
• O(nlogn)
• O(n²)
• O(n³)
• O(2^n)
• O(n!)

这里举个例子来讲解如何计算时间复杂度的大O表示法

// 请计算一下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;
}
printf("%d\n", count);
}

F(N)=N²+2*N+10

• N=10 ----------- F(N)=130
• N=100 ----------F(N)=10210
• N=1000---------F(N)=1002010

当N越来越大时，2*N和10对F(N)的影响可以忽略，所以F(N)的值主要由N²来决定，所以该算法的大O表示法为O(n²)

大O的渐进表示法

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

1. 用常数1去掉运行时间的所有加法常数
2. 在修改后的运行次数函数中，只保留最高项
3. 使最高项的系数为1，得到大O表示法

对于存在最好、最坏、平均的时间复杂度算法
最坏情况：任意输入规模的最大运行次数
最好情况：任意输入规模的最小运行次数
平均情况：任意输入规模的期望运行次数
例如：在一个长度为N数组中搜索一个数据x
最好情况：1次搜索到x
最坏情况：搜索N次仍然没有找到x
平均情况：搜索2/N次
在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)

常见的时间复杂度举例

示例一

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

时间复杂度O(n):基本循环语句执行次数为2n+10，忽略常数项和最高项系数就是n

示例二

void Func3(int N, int M)
{

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

时间复杂度为O(m+n),基本循环语句执行次数为m+n

示例三

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

时间复杂度为O(1):循环体执行的次数为100,是一个常数，所以时间复杂度为O(1)

示例四

// 计算strchr的时间复杂度？
const char * strchr ( const char * str, int character )

时间复杂度为O(n²):strchr函数是在字符串中寻找某一个字符第一次出现的位置，所以时间复杂度最好的情况是O(1),最坏的情况是O(n²)，时间复杂度取决于最坏情况

示例五

// 计算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²):考虑最坏情况，数组从大到小排序，这样总共的循环次数就是(n-1)+(n-2)+……+(0),也就是(n²-1)/2，所以时间复杂度为O(n²)

示例六

// 计算BinarySearch的时间复杂度？
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;
 else
 return mid;
 }
 return -1;
}

时间复杂度为O(log₂n):由二分查找的定义可以直到，二分查找每次执行循环体一次，目标区间会缩小一半，最坏情况下查找的元素为两边的端点，所以在最坏情况下一定有等式n/2^k=1(k为循环体执行次数)，所以k=log₂n

示例七

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

时间复杂度为O(n):递归也是循环的一种，当n为0时，递归结束，所以循环体一共执行n次

示例八

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

时间复杂度为O(1.6ⁿ):

在上述例子中，如果将红色框部分补齐的话那么上述总共会调用2⁰+2¹+…+2^n-2次函数，这样算出来的时间复杂度就是O(2ⁿ),所以说时间复杂度的一个上限是O(2ⁿ),但这绝对不是最小上限，最小上限为O(((1+sqrt(5))/2)ⁿ)大约是O(1.6ⁿ)
感兴趣的朋友可以看这篇文章递归求斐波那契数列的时间复杂度

---

空间复杂度

大O的渐进表示法

考虑算法的效率除了要考虑算法的时间效率，还需要考虑到算法的空间效率，和时间复杂度一样，我们无法直接知道每一台机器上一个算法具体消耗的内存有多少kb,所以我们也使用[ 大O符号表示法 ]表示一个算法的空间效率，S(n)=O(f(n)),f(n)表示对一个算法在运行过程中临时占用存储空间大小的量度

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

常见的空间复杂度举例

示例一

// 计算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(1):在程序运行时,每一次循环只会开辟一个额外的空间exchange,所以空间复杂度为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;
}

空间复杂度为O(n):动态内存分配是在程序运行时才进行内存分配，所以产生的数组空间是程序运送时额外开辟的，所以空间复杂度为O(n)

示例三

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

空间复杂度为O(n):
每一个参数不为0的函数都会调用一个函数，所以最开始的参数为n的话，运行时会调用n次递归函数，会额外开辟n个函数栈帧，所以空间复杂度为O(n)

示例四

//计算fib递归函数的空间复杂度
int fib(int n)
{
	if (n < 3)
		return 1;
	else
		return fib(n - 1) + fib(n - 2);
}

空间复杂度O(n)：在此之前我们来回顾一下栈区的特性-----栈区空间的使用习惯是先使用高地址，后使用低地址，栈区中存放的是局部变量、函数栈帧。当函数调用结束后或者变量生命周期结束后、该区域会归还给线程。以便下次调用
先思考下面代码

为什么两个函数中开辟变量的地址是一样的？

由栈区使用习惯可知：当fun1函数会建立一个函数栈帧，变量a是在该栈帧中创建的，fun1函数结束时、会销毁函数栈帧，原本fun1所占用的空间归还给进程以便再次利用该空间，那什么时候需要再次利用该空间呢？答案是当fun2函数调用的时候会利用和函数fun1开辟的相同的栈帧，原因在于fun2的结构和fun1的结构是一模一样的，尽管变量名和数据不一样，但是从内存的角度来看只需要知道这两函数都是初始化了一个int的变量和执行了printf函数语句，本质上没有区别，所以当两个函数的栈帧是一样的，既然栈帧一样，那么两个函数也一定是在同一个为自豪定义变量的

现在回到最开始的问题，为什么递归的斐波那契空间复杂度是O(n)?
来看下面这张图

调用fib函数时，会先调用最左边的fib(n-1),fib(n-2)…fib(3)…fib(2)，此时额外开辟的栈桢数是n-1,当执行完fib(2)后，fib(2)的空间会被回收，fib(2)返回是为了计算fib(3),所以当fib(2)返回后回调用fib(1),由之前分析可知fib(1)的空间是fib(2)销毁的栈帧空间，所以此时额外开辟的空间仍然是n-1，计算fib(4)时fib(2)分配的空间是fib(3)销毁的空间，计算fib(5)时fib(3)分配的空间是fib(4)销毁的空间，计算fib(3)时又会为fib(2)\fib(1)开辟空间，fib(1)的空间就是fib(2)销毁的空间，以此类推，最后额外开辟的空间最多就是n-1个函数栈帧，所以空间复杂度为O(n)

---

️常见复杂度对比️

5201314	O(1)	常数阶
3n+4	O(n)	线性阶
3n2+4n+5	O(n2)	平方阶
3log2n+4	O(log2n	对数阶
2n+3nlog2n+14	O(nlog2n)	nlog2n阶
n3+2n2+4	O(n3)	立方阶
2n	O(2n)	指数阶