时间复杂度空间复杂度 复杂度分析

复杂度分析是算法学习的精髓。

为什么需要复杂度分析？
其实把代码跑一遍，通过统计、监控、就能得到算法的执行时间和内存的占用，为什么还要复杂度分析呢，原因是这种事后分析法具有非常大的局限性。
1.测试结果非常依赖测试环境。一段代码在i9的处理器上运行和i3的处理器上运行速度显然是不同的，i9的处理器的速度要快得多。
2.测试结果受数据规模的影响。对于排序算法而言，原本有序的数据，进行排序，则运行时间会非常短。对于规模小的排序算法，插入排序可能会比快速排序更快。

大O复杂度表示法
从cpu的角度来看，这段代码的每一行都执行着读数据-运算-写数据的操作，尽管每行代码对应的CPU执行的个数、执行的时间都不一样，但是只是粗略的估计，可以假设每行代码执行的时间相同。

大O复杂度表示法只是一种变化的趋势，通常会忽略掉公式中的常量、低阶、系数，只需要记录最大阶量级就可。

时间复杂度分析
有以下三种方法
1.只关注循环执行最多的一段代码

int func(int n)
{
	int sum=0;
	int i=1;
	for(;i<=n;++i)
	{
		sum=sum+i;
	}
	return sum;
}

此段代码的时间复杂度是O(n)。

2.加法法则：总复杂度等于量级最大的那段代码的复杂度

int cal(int n)
{
   int sum_1=0;
   int p=1;
   for (;p<100;++p)
   {
     sum_1=sum_1+p;
   }
   int sum_2=0;
   int q=1;
   for (;q<n;++q)
   {
     sum_2=sum_2+q;
   }
   int sum_3=0;
   int i=1;
   int j=1;
   for (;i<=n;++i)
   {
     j=1; 
     for (;j<=n;++j)
     {
       sum_3=sum_3+i*j;
     }
   }
   return sum_1+sum_2+sum_3;
}

这个代码分为三部分，分别是求 sum_1、sum_2、sum_3。我们可以分别分析每一部分的时间复杂度，然后把它们放到一块儿，再取一个量级最大的作为整段代码的复杂度。
第一段时间复杂度是常量可记为O(1)；
第二段时间复杂度是O(n)；
第三段时间复杂度是O(n²)；
因此取最大量级则时间复杂度为O(n²)；

3.乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积

int cal(int n) {
   int ret = 0; 
   int i = 1;
   for (; i < n; ++i) {
     ret = ret + f(i);
   } 
 } 
 
 int f(int n) {
  int sum = 0;
  int i = 1;
  for (; i < n; ++i) {
    sum = sum + i;
  } 
  return sum;
 }

我们单独看 cal() 函数。假设 f() 只是一个普通的操作，那第 4～6 行的时间复杂度就是，T1(n) = O(n)。但 f() 函数本身不是一个简单的操作，它的时间复杂度是 T2(n) = O(n)，所以，整个 cal() 函数的时间复杂度就是，T(n) = T1(n) * T2(n) = O(n*n) = O(n²)。

几种常见时间复杂度实例分析
常量阶O(1)
对数阶O(logn)
线性阶O(n)
线性对数阶O(nlogn)
平方阶O(n²)
立方阶O(n³)
k次方阶O(n^k)
指数阶O(2ⁿ)
阶乘阶O(n!)
特殊O(m+n)、O(m*n)

有些例子已经在上面进行了分析，只简单介绍一下下面几种
O(logn)、O(nlogn)

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

从代码中可以看出，变量 i 的值从 1 开始取，每循环一次就乘以 2。当大于 n 时，循环结束。相当于一个等比数列
2⁰ 、 2¹ 、 2² 、 2³ 、 2⁴ ···· 2^x = n
因此只要求出x，既可以得到时间复杂度 x=log₂n
在采用大 O 标记复杂度的时候，可以忽略系数。因此，在对数阶时间复杂度的表示方法里，我们忽略对数的“底”，统一表示为 O(logn)。

把刚才那段代码执行了n遍运用乘法法则，可以得到 O(nlogn)。

O(m+n)、O(m*n)

int cal(int m, int n) {
  int sum_1 = 0;
  int i = 1;
  for (; i < m; ++i) {
    sum_1 = sum_1 + i;
  }

  int sum_2 = 0;
  int j = 1;
  for (; j < n; ++j) {
    sum_2 = sum_2 + j;
  }
  return sum_1 + sum_2;
}

代码的复杂度由两个数据的规模来决定

空间复杂度分析
空间复杂度全称就是渐进空间复杂度，表示算法的存储空间与数据规模之间的增长关系

void print(int n) {
  int i = 0;
  int[] a = new int[n];
  for (i; i <n; ++i) {
    a[i] = i * i;
  }
  for (i = n-1; i >= 0; --i) {
    print out a[i]
  }
}

第 2 行代码中，申请了一个空间存储变量 i，但是它是常量阶的，跟数据规模 n 没有关系，所以可以忽略。第 3 行申请了一个大小为 n 的 int 类型数组，除此之外，剩下的代码都没有占用更多的空间，所以整段代码的空间复杂度就是 O(n)。我们常见的空间复杂度就是 O(1)、O(n)、O(n²)，像 O(logn)、O(nlogn) 这样的对数阶复杂度平时都用不到。
空间复杂度分析比时间复杂度分析更简单。