算法的时间复杂度与空间复杂度

算法：

算法是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作

算法的复杂度：

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

时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间

目录

一. 时间复杂度

1. 定义

2. 大O的渐进表示法

3.最好情况，最坏情况和平均情况

4.时间复杂度计算举例：

（1）常数阶

（2）线性阶

（3）平方阶

（4）对数阶

5.常见的时间复杂度

二. 空间复杂度

1. 定义

2. 空间复杂度的计算举例

---

一. 时间复杂度

1. 定义

在计算机科学中，算法的时间复杂度是一个函数（数学函数），它定量描述了该算法的运行时间。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度

实例：

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

Func1执行的基本操作次数：F(N)=N^2+2*N+10

但实际计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，所以我们这里使用大O的渐进表示法

2. 大O的渐进表示法

那么如何推导大O阶呢？请看下面的推导方法：

1.用常数1取代运行时间中所有的加法常数

2.在修改后的运行次数函数中，只保留最高阶项

3.如果最高阶项存在且不是1，则去除与这个项目相乘的常数，得到的结果就是大O阶

使用大O的渐进表示法后，Func1的时间复杂度为： O(N^2)

通过上面，我们发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数

3.最好情况，最坏情况和平均情况

最好情况：任意输入规模的最小运行次数

平均情况：任意输入规模的期望运行次数

最坏情况：任意输入规模的最大运行次数

例如我们查找一个有n个随机数字数组中的某一个数字最好的情况是第一个数字就是，那么算法的时间复杂度就是O(1)，但也有可能这个数字在最后一个位置，那么算法的时间复杂度就为O(n)，这是最坏的一种情况

在实际中一般关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(n)

4.时间复杂度计算举例：

（1）常数阶

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

根据推导大O阶的方法第一步就是把常数项100改为1，在保留最高阶项时发现，它根本没有最高阶项，所以这个算法的时间复杂度为O(1)

 不管（k<100）这个常数是多少，我们都记作O(1),而不能是O(3),O(12)等其他任何数字

O(1)并不是代表1次，而是代表常数次

（2）线性阶

下面这段代码，它的循环的时间复杂度为O(n)，因为循环中的代码必须要执行n次

int i;
for(i=0;i<n;i++)
{
   /*所要执行代码*/
}

（3）平方阶

int main()
{
	int i, j;
	int n;
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)
		{
			/*所要执行代码*/
		}
	}
	return 0;
}

这是一个循环嵌套，它的内循环我们已经分析过，时间复杂度为O(n)，而对于外层循环，就是内部这个时间复杂度为O(N)的语句，再循环n次，所以这段代码的时间复杂度为O(n^2)

如果外层循环的次数改为了m，时间复杂度就为O(m*n)

再看下面的循环嵌套，它的时间复杂度是多少呢？

int main()
{
	int i, j;
	int n;
	for (i = 0; i < n; i++)
	{
		for (j = i; j < n; j++)
		{
			/*所要执行代码*/
		}
	}
	return 0;
}

 所以总执行次数：n+(n-1)+(n-2)+...+2+1=n(n+1)/2，再利用推导大O阶的方法，最终这段代码的时间复杂度为O(n^2)

（4）对数阶

	int count = 1;
	int n;
	while (count < n)
	{
		count = count * 2;
	}

count每乘一次2，就离n更近了，所以有多少个2相乘后大于n，就会退出循环

由2^x=n，得到x=log2(n)（log以2为底n的对数）, 所以这个循环的时间复杂度为O(logn)

5.常见的时间复杂度

 常用的时间复杂度所耗费的时间从小到大依次是：

二. 空间复杂度

1. 定义

空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用额外存储空间大小的度量

空间复杂度不是程序占用了多少字节的空间，空间复杂度算的是变量的个数，计算规则与时间复杂度类似，也使用大O渐进表示法

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

算法在运行的过程中开辟了end，i，exchange这样的额外的空间，但都是常数个，所以空间复杂度为O(1)

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

递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间，所以空间复杂度为O(N)

注意：函数运行时所需要的栈空间（存储参数，局部变量，一些寄存器信息等）在编译期间就已经确定好了，因此空间复杂度主要通过函数在运行时候显示申请的空间来确定（显示申请的空间即为我们为了完成算法需要开辟的空间）

---

若有文章有任何问题，欢迎大家指正