时间复杂度、空间复杂度

时间复杂度、空间复杂度

1.1 算法效率

我们用时间复杂度和空间复杂度来表征算法执行的效率。由于如今计算机存储能力大大增强，所以对空间复杂度没有太大的关注。而时间复杂度意味着这个算法需要跑多长时间，这个能够被用户直观的感受到，所以，在采用算法时会特别关注时间复杂度。

1.2 时间复杂度

1.2.1 定义与注意

时间复杂度表征的是一个算法的运行时间效率，我们把算法中的基本操作的执行次数，称作算法的时间复杂度。

而时间复杂度分为：最好情况，最坏情况，平均情况。而在设计算法，应用算法时，时间效率是一种很重要的需求，所以我们一般所说的运行时间指的是最坏情况的运行时间。

1.2.2 求算方法

在求算法的时间复杂度时，我们一般采用大O符号法来进行近似的求算。

先看推导大O的方法：
1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。

1.2.3 求算时间复杂度举例

1.2.3.1 几个常见的时间复杂度及所耗时间排序：

1.2.3.2 列举几个求算的例子：

常数阶

在下方代码中，打印100次i需要执行100次，那么这个算法需要的执行次数就是100次。对应规则1，用常数1取代运行时间中的所有加法常数，且无最高阶，所以最后时间复杂度为O（1）；这种与问题的大小无关，执行次数恒定的算法，我们称它为具有O（1）的时间复杂度，又叫常数阶。

#include<stdio.h>

int main()
{
    for(int i=0;i<100;i++)
    {
		printf("%d",i);
	}
	return 0;
}

线性阶

在下方代码中，循环体printf("%d",i)的执行次数与N的值有关，N的值代表着算法的执行次数，所以时间复杂度为O（N）。

在这类算法中，很明显可以知道循环体的执行次数和N有关。所以复杂度就为O（N）。

#include<stdio.h>

int main()
{
    int N =100;
    for(int i=0;i<N;i++)
    {
		printf("%d",i);
	}
	return 0;
}

对数阶

这段代码中，很明显，循环结束的条件是count<n，也就是说，x个2相乘之后大于n结束循环，再进一步说就是：循环体要执行2的x次方次，那么将其转换为对数，为x=log₂N，但由于底是一个常数，在代码中可以是2，可以是3，无关紧要，所以我们一般写成O（logN)

#include<stdio.h>

int main()
{
    int count =1;
    int N = 100;
	while(count<N)
	{
		count *= 2;
    }
	return 0;
}

平方阶

• 对于这段代码，内部的循环体的执行次数就是外部循环体的循环次数乘以其本身循环次数。也就是N*N，即N₂，一般写成O（N₂）

#include<stdio.h>

int main()
{
    int N =100;
    for(int i=0;i<N;i++)
    {
        for(int j =0;j<N;j++)
        {
            printf("%d",i);
		}
    }
	return 0;
}

• 对于这段代码，当i=0时，内循环执行了n次，i=1时，内循环执行n-1次，所以总的执行次数就是一个等差数列的求和公式：（n（n+1)）/2

  用推导大O阶的方法，我们简化之后保留近似的复杂度为O（N₂）

#include<stdio.h>

int main()
{
    int N =100;
    for(int i=0;i<N;i++)
    {
		for(int j=i;j<n;j++)
        {
        	printf("%d",i);
        }
	}
	return 0;
}

1.2.4 小总结

• 在描述算法运行效率的时候，我们通过求算算法的运行次数来作为算法的时间复杂度。

• 但是求算复杂度的时候我们要明白一点，求算时间复杂度首先要做的是得到运行次数的数学表达式，这个是需要数学功底的，列出了表达式，大O阶就是小case。

• 求算复杂度时不能光看代码得到表达式，需要画图，理解算法内核，核心思想是什么。

• 时间复杂度的重要性体现在一个程序在一个复杂度为O（n）和复杂度为O（n²）,对于这个算法来说，是100倍的差距。学会如何去求算时间复杂度是一名程序员修养的体现。

1.3 空间复杂度

1.3.1 定义与注意

• 空间复杂度是对一个算法在运行过程中临时额外占用存储空间大小的量度 。怎么去理解呢，实际上在函数运行之前，函数所需的栈空间（包含存储参数，局部变量，一些寄存器变量等）就已经在编译阶段确定了，所以我们的空间复杂度实际计算的是在函数运行时显式申请的额外空间。就如下方代码样例

• 空间复杂度求的是算法中额外的变量的个数，而非算法所用空间字节数

• 求算时按照时间复杂度的大O阶求三个法则即可

eg：

//空间复杂度为O（1）
void fun(int a)//这个a就不是
{
	int b=0;//这个变量就是临时额外占用的空间
}

int main()
{
    int a=0;
	fun(a);    
	return 0;
}

1.3.2 求算举例

• 在这段代码中，使用了常数个额外空间。我们要算的是函数运行时所占用的额外空间，那么在这个代码里，定义了一个end变量，和一个i变量，end变量在整个算法执行过程中只会创建一次，而i虽然会被创建n次但在栈空间中，它会不断地被创建和销毁，即出了第二个循环就销毁，进入第二个循环重新创建，这是因为它的生命周期只存在于第二个for循环，也因此，它相当于只占用了栈空间里的一个位置。所以说，这段代码使用了常数个额外空间，所以，空间复杂度为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）*sizeof（long long）个字节的空间,也即开辟了n个空间，由于是大O阶方法（近似运算），所以空间复杂度为O（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次栈空间，栈空间内有额外常数个变量，所以空间复杂度为O（N）

  我们要注意，空间是可以被重复利用的，也就是说，我们求算递归的空间复杂度，只需要关注递归的深度就够了，因为代码是先执行Fac(N-1)，再执行Fac（N-2）的，那么我们可以明确的是Fac（N-1）这层递归会不断递归下去直到条件满足返回栈空间，然后求另一个递归，如下图。

  我们可以在图中看到，递归的深度是n-1，在第一列递归走完后返回栈空间，然后其余递归继续在这些栈空间上开辟函数栈帧。

long long Fac(size_t N)
{
    if(N<3)
        return 1;
	return Fac(N-1)+Fac(N-2);
}

1.4大总结

• 在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。
• 在需要的时候完全可以以空间换取时间
• 懂得求算时间复杂度很重要很重要很重要！！！