数据结构与算法之美学习笔记01－复杂度分析

本文链接：https://blog.csdn.net/qq_37569355/article/details/102470136

本文详细介绍了大Ｏ复杂度表示法，强调了时间复杂度分析的关键点，如忽略常量、低阶项和系数。文章讨论了加法和乘法法则在计算总复杂度时的应用，并列举了常见的时间复杂度量级，包括多项式和非多项式量级。还深入探讨了对数阶分析，并简要提到了复杂度分析的进阶概念，如最好、最坏和平均时间复杂度以及均摊时间复杂度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

大Ｏ复杂度表示法

$Ｔ\left ( ｎ \right ) ＝$ $T(a) = O(f(n))$
表示代码执行时间随数据规模增长的变化趋势，也叫做渐进时间复杂度,简称时间复杂度

时间复杂度分析的四个比较常用的方法

只关注循环执行次数最多的一次代码

忽略掉代码中的常量、低阶、系数，秩只需记录一个最大阶数的量级就可以了。

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

如果 T1(n)=O(f(n))，T2(n)=O(g(n))；那么T(n) = T1(n) + T2(n) = max(O(f(n)), O(g(n))) = O(max(f(n), g(n)))

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

对上面代码采用加法法则，时间复杂度为O( $n^{2}$ )

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

如果 T1(n)=O(f(n))，T2(n)=O(g(n))，那么 T(n)=T1(n)*T2(n)=O(f(n))*O(g(n))=O(f(n)*g(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;
}

从上面代码可以看出，此时时间复杂度为O(m + n)。

此处区分加法法则，由于此时ｍ、ｎ的规模事先不清楚！！！

几种常见时间复杂度

多项式量级

常量阶 O(1)
对数阶 O(logn)
线性阶 O(n)
线性对数阶 O(nlogn)
平方阶 O( $n^{2}$ )、立方阶 O( $n^{3}$ ) ... k次方阶 O( $n^{k}$ )

非多项式量级

上图中的其余量级的时间复杂度称为非多项式量级的算法问题叫做NP(非确定多项式)问题。

非多项式时间复杂度的算法是非常低效的算法。

对数阶分析

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

如上面代码所示，i值的取值是等比数列。我们如何知道代码总的执行次数呢？

我们只要知道x为多少就可以了。通过 $2^{x} = n$ ，我们求解x。通过换底公式可以得知： $x = log_{2}n$ 。从计算结果来看，这段代码的时间复杂度为 O( $log_{2}n$ )。但是我们常用的对数阶公式为 $log_{10}n$ 。

在实际分析中，无论是以那个数为底，我们都可以把对数阶的时间复杂度记为 O(log n)。希望能通过这个例子，更好理解对数阶这一量级分析。

同样的 O(ｎlog n)相当于将 O(log n)循环执行ｎ次即可！

复杂度分析进阶

// n表示数组array的长度
int find(int[] array, int n, int x) {
  int i = 0;
  int pos = -1;
  for (; i < n; ++i) {
    if (array[i] == x) {
       pos = i;
       break;
    }
  }
  return pos;
}

分析上面的代码，我们要查找的变量ｘ可能出现在数组的任意未知。如果数组中第一个元素正好是要查找的变量ｘ，那就不需要继续遍历剩下的ｎ－１个数据了，时间复杂度为Ｏ（１）。但如果数组中不存在变量ｘ，那就需要遍历整个数组，时间复杂度就变成了Ｏ（ｎ）。不同情况下的代码的时间复杂度是不一样的，故引入如下概念：

最好情况时间复杂度：代码在最理想情况下执行的时间复杂度。
最坏情况时间复杂度：代码在最坏情况下执行的时间复杂度。
平均时间复杂度：用代码在所有情况下执行的次数的加权平均值表示。
均摊时间复杂度：在代码执行的所有复杂度情况中绝大部分是低级别的复杂度，个别情况是高级别复杂度且发生具有时序关系时，可以将个别高级别复杂度均摊到低级别复杂度上。基本上均摊结果就等于低级别复杂度。
平均和平摊基本就是一个概念，平摊是特殊的平均。在分析时间复杂度是O(1)还是O(n)的时候最简单就是凭感觉，出现O(1)的次数远大于出现O(n)出现的次数，那么平均平摊时间复杂度就是O(1)。

分析下面代码的时间复杂度：

// 全局变量，大小为 10 的数组 array，长度 len，下标 i。
int array[] = new int[10]; 
int len = 10;
int i = 0;

// 往数组中添加一个元素
void add(int element) {
   if (i >= len) { // 数组空间不够了
     // 重新申请一个 2 倍大小的数组空间
     int new_array[] = new int[len*2];
     // 把原来 array 数组中的数据依次 copy 到 new_array
     for (int j = 0; j < len; ++j) {
       new_array[j] = array[j];
     }
     // new_array 复制给 array，array 现在大小就是 2 倍 len 了
     array = new_array;
     len = 2 * len;
   }
   // 将 element 放到下标为 i 的位置，下标 i 加一
   array[i] = element;
   ++i;
}

最好时间复杂度：O(1)

最坏时间复杂度：O(n)

平均时间复杂度：O(1)