数据结构复杂度分析

杨利霞

数据结构复杂度分析

2 o" E9 [" g+ M( t- r+ @文章目录
前言
; t( x4 `9 g, W5 h$ F# p  C一、什么是复杂度分析？
' F( P3 I, S1 Y1 o/ `2 x* P二、为什么要进行复杂度分析？
三、如何进行复杂度分析？
" x8 c) v9 z: Q' H# X8 H1. 大O表示法
2. 复杂度分析法则
- r+ P6 h, k4 ~* U% ^四、常用的复杂度级别？
1. 常数阶O(1)
2. 线性阶O(n)
3. 平方阶O(n2)
4. 对数阶O(logn)
五、不常见的时间复杂度
3 q6 H! J% ]8 B6 Q# \1 S7 e' T1. 最好情况时间复杂度（best case time complexity）
/ p2 q8 h! _; H/ d) G8 y2. 最坏情况时间复杂度（worst case time complexity）
3. 平均情况时间复杂度（average case time complexity）
1 e: p% T3 x+ b+ f* r, M4. 均摊时间复杂度（amortized time complexity）
3 a( Q; t( d6 k5 |; s% {六、如何掌握好复杂度分析方法？
1. 大O标记
总结
! S% W. I* U$ {前言
提到数据结构+算法的学习，有两个问题是不可避免的，一个是时间复杂度，可以理解为算法的运行时间，如果算法运行时间太长，那这个算法就没法用；另一个是算法的空间复杂度，可以理解为把算法存储在计算机中需要多大的空间，如果需要空间太大，那这个算法也没法用。因此，需要对一个算法的时间复杂度和空间复杂度进行分析，来确定该算法的可行性。

一、什么是复杂度分析？
数据结构和算法解决的是：如何让计算机更快时间、更省空间的解决问题。
因此需从执行时间和占用空间两个维度来评估数据结构和算法的性能。
& D" z  O" k! r" t  `5 ]$ `4 X分别用时间复杂度和空间复杂度两个概念来描述程序性能，二者统称为复杂度。
: u" f$ z2 L" {1 W复杂度描述的是算法执行时间（或占用空间）与数据规模的增长关系。
, {- \0 J! A$ I: z. B+ x二、为什么要进行复杂度分析？
. `7 a9 n  q( `! V和性能测试相比，复杂度分析有不依赖执行环境、成本低、效率高、易操作、指导性强的特点。
0 {% ~. b7 Z5 I" T9 T掌握复杂度分析，将能编写出性能更优的代码，有利于降低系统开发和维护成本。
三、如何进行复杂度分析？
1. 大O表示法
1）来源
4 X- v7 x. M3 ]5 v
7 y* _0 A9 x8 n算法的执行时间与每行代码的执行次数成正比，用T(n) = O(f(n))表示，其中T(n)表示算法执行总时间，f(n)表示每行代码执行总次数，而n往往表示数据规模。

2 E8 e- G# n' E% `7 _/ d2）特点
- |* K2 Z# g+ W. K
" o/ a+ D! k3 x# S. ]5 e$ {以时间复杂度为例，由于时间复杂度描述的是算法执行时间与数据规模的增长变化趋势，所以常量阶、低阶以及系数实际上对这种增长趋势不产决定性影响，所以在做时间复杂度分析时忽略这些项。

1 N  {2 Q* D1 @+ j- E( `  W2. 复杂度分析法则
- Z' T- E  _6 |# U4 {9 _1）单段代码看高频：比如循环。
) j' ^( `$ X2 O* M8 E: K4 {
. P1 j: ^( k; o0 d3 d( U2）多段代码取最大：比如一段代码中有单循环和多重循环，那么取多重循环的复杂度。

3）嵌套代码求乘积：比如递归、多重循环等。
+ V2 S5 L) [2 i7 n2 Z* _+ b
4）多个规模求加法：比如方法有两个参数控制两个循环的次数，那么这时就取二者复杂度相加。

四、常用的复杂度级别？
0 m, y# m& S, Q) m多项式阶：随着数据规模的增长，算法的执行时间和空间占用，按照多项式的比例增长。包括， O(1)（常数阶）、O(logn)（对数阶）、O(n)（线性阶）、O(nlogn)（线性对数阶）、O(n^2 ) （平方阶）、O( n^3)（立方阶）

非多项式阶：随着数据规模的增长，算法的执行时间和空间占用暴增，这类算法性能极差。包括， O( 2^n )（指数阶）、O(n!)（阶乘阶）

' n% p4 k) l( K8 G5 y复杂度量级排序：
# ?/ Q6 V' c( d, y

1. 常数阶O(1)
/ c/ i3 S/ H4 l+ P0 T无论代码执行了多少行，其他区域不会影响到操作，这个代码的时间复杂度都是O(1)
6 ~$ b. T* X1 h- |
* u4 y$ A; r+ L
void swapTwoInts(int &a, int &b)
  }+ N5 t6 F) H6 p; e2 v# ]2 i{
        int temp = a;
        a = b;
8 d9 Y3 J; U0 |  D9 b        b = temp;
4 ?' |! }" l' q3 C% @) ~7 s0 @* J}
& R+ U4 U/ b3 H& z7 N1
2
" y: F: K4 v$ u& S3
, m4 l2 h4 ]1 n2 E( |0 O4 |% g4
& z' R6 i" q& A2 P5
. C5 e8 k4 q, C0 G5 F$ @9 d6
4 f# ?* r# o1 d, T; o& _& J2. 线性阶O(n)

( H2 n# O1 |+ }% {1 L1 W& Z& V在下面这段代码，for循环里面的代码会执行 n 遍，因此它消耗的时间是随着 n 的变化而变化的，因此可以用O(n)来表示它的时间复杂度。
1 Y7 D2 N$ m$ r! L4 J
int sum ( int n )
{
: F- S5 P- s/ l* e2 S: b3 g        int ret = 0;
8 k, X7 j  x) i$ P, e! @& i5 m        for ( int i = 0 ; i <= n ; i ++)
" k; [( q7 n  k" ^4 x. }        {
        ret += i;
        }
        return ret;
}
" K) X; K9 s" H2 L# ^; |/ q1
2
6 [$ Q( p5 r# F2 `$ h( X3
7 W2 M- D* F3 Y( T* b8 s4
* l4 n# g" ^  {9 C% d5 K) H5
6
; E* Z' s. L' ]: y$ h% F7 k$ j4 N7
8
9
3. 平方阶O(n2)
' j$ q% \$ z/ s, b5 D8 F- y当存在双重循环的时候，即把 O(n) 的代码再嵌套循环一遍，它的时间复杂度就是 O(n2) 了。

, ?5 w6 S* o1 z& j* [6 {3 C
3 `# r1 a5 O; H' A+ G4 S1 Ivoid selectionSort(int arr[],int n){
        for(int i = 0; i < n ; i++){
        int minIndex = i;
        for (int j = i + 1; j < n ; j++ )
5 i- {; _0 `8 ?6 V" Z! [                 if (arr[j] < arr[minIndex])
6 T1 J. P% K8 x" z                         minIndex = j;
                        swap ( arr, arr[minIndex]);
2 W9 x8 l1 L& _: R9 J" v         }
7 H& t5 P8 m! Q7 r        }
0 k1 d2 g2 X, l1
2
3
4
5
+ G0 M+ i# P$ o* p6
7
8
9
) G' K6 h2 b9 g! @这里简单的推导一下
9 c$ ^2 [: |, d: {# e3 j# c
当 i = 0 时，第二重循环需要运行 (n - 1) 次

当 i = 1 时，第二重循环需要运行 (n - 2) 次
- F2 @- r4 G/ ?7 q3 Q
。。。。。。
; V* [0 _- ?3 l, y8 w7 A
2 t5 X. F# U- q) t不难得到公式：
8 y" `6 n! U; e7 h4 ]
(n - 1) + (n - 2) + (n - 3) + ... + 0
# s; I. i. p1 O' \+ m$ y= (0 + n - 1) * n / 2
= O (n ^2)
) d; m1 g/ j8 w/ H) {1
1 w/ i3 K( f6 @6 m2
% z: q) F0 p6 A* a3
4. 对数阶O(logn)
: U& L2 Q. H$ r' Z

int binarySearch( int arr[], int n , int target){
        int l = 0, r = n - 1;
  B# J' H9 d( O  X, U. Q         while ( l <= r) {
        int mid = l + (r - l) / 2;
             if (arr[mid] == target) return mid;
& _& K0 n1 `. w" n3 ^# X# P$ I            if (arr[mid] > target ) r = mid - 1;
9 Y" H$ u, h, ]- F' E            else l = mid + 1;
   }
) M" j9 q- t( {: ^$ C return -1;
3 s9 U+ ]! x1 `% k5 U1 K}
1
* n/ G/ y  B% y% H6 n2
3
+ \) K! r4 s0 O( Q5 H; F4
5
. O& t# v7 Y$ H6
2 k2 d$ t3 T3 L% P+ t8 W: f7 D7
/ r3 v$ {4 g3 u1 X& S3 c8
: F& s9 T5 o: m  R9
10
% J+ i" X( E9 f2 s; @7 Y在二分查找法的代码中，通过while循环，成 2 倍数的缩减搜索范围，也就是说需要经过 log2^n 次即可跳出循环。

' W! k/ ]# w! c8 I( \3 A五、不常见的时间复杂度
% L$ p( _' S0 v! q1. 最好情况时间复杂度（best case time complexity）
最好情况时间复杂度就是，在最理想的情况下，执行这段代码的时间复杂度。在最理想的情况下，要查找的变量 x 正好是数组的第一个元素，这个时候对应的时间复杂度就是最好情况时间复杂度。

+ h/ Q# x4 U2 a* J5 ~2. 最坏情况时间复杂度（worst case time complexity）
) T/ X( C8 X/ q' h# H# G% ~最坏情况时间复杂度就是，在最糟糕的情况下，执行这段代码的时间复杂度。如果数组中没有要查找的变量 x，我们需要把整个数组都遍历一遍才行，所以这种最糟糕情况下对应的时间复杂度就是最坏情况时间复杂度。
# U4 j$ |6 _& s
1 m" {: x4 P1 X/ }4 p  v$ {最好、最坏情况时间复杂度指的是特殊情况下的时间复杂度。
动图表明的是在数组 array 中寻找变量 x 第一次出现的位置，若没有找到，则返回 -1；否则返回位置下标。

$ c' ?/ _/ e8 H/ aint find(int[] array, int n, int x) {
  for (  int i = 0 ; i < n; i++) {
    if (array == x) {
        return i;
6 J2 s9 _0 M) {, r/ A, c; V0 Q- @        break;
    }
, d% `: t5 X4 e: ?: g" V+ z  }
  return -1;
5 Z$ |) F+ F6 Z( A* q8 S}
1
2
3
8 i: u6 R9 J, G# n! \4 ^4
" k" h4 `0 ~* Y* e: T1 m5
6
1 g- \- ~# K1 ?; j  }! i$ E, g& [& F7 q/ t# t7
8 ]/ u5 q9 V$ q% Z  k6 j. N8 i8
9
在这里当数组中第一个元素就是要找的 x 时，时间复杂度是 O(1)；而当最后一个元素才是 x 时，时间复杂度则是 O(n)。

: _  l, O6 t6 R' w4 g最好情况时间复杂度就是在最理想情况下执行代码的时间复杂度，它的时间是最短的；最坏情况时间复杂度就是在最糟糕情况下执行代码的时间复杂度，它的时间是最长的。

3. 平均情况时间复杂度（average case time complexity）
最好、最坏时间复杂度反应的是极端条件下的复杂度，发生的概率不大，不能代表平均水平。那么为了更好的表示平均情况下的算法复杂度，就需要引入平均时间复杂度。
' |% f: e( s1 I% V& _+ F! g. L6 e+ s
平均情况时间复杂度可用代码在所有可能情况下执行次数的加权平均值表示。
- w7 W# O+ x1 q
' f3 i/ i0 V$ v6 Q' ?" m3 v0 N( A还是以 find 函数为例，从概率的角度看， x 在数组中每一个位置的可能性是相同的，为 1 / n。那么，那么平均情况时间复杂度就可以用下面的方式计算：
0 Y7 C" g* {6 V  l) O* o$ v" m( R
((1 + 2 + … + n) / n + n)  /  2 = (3n + 1) / 4
6 d- ^' _+ u  [- c1

  n6 H$ I4 }3 d3 q2 t$ l' cfind 函数的平均时间复杂度为 O(n)。

4. 均摊时间复杂度（amortized time complexity）
我们通过一个动态数组的 push_back 操作来理解 均摊复杂度。
8 H- i5 \& s: o- W, T

template <typename T>
class MyVector{
* X+ I+ J8 R3 j" C. @$ l9 |! y. z private:
     T* data;
     int size;       // 存储数组中的元素个数
* w6 M, }6 W! I7 s0 D     int capacity;   // 存储数组中可以容纳的最大的元素个数
     // 复杂度为 O(n)
     void resize(int newCapacity){
" Q- U8 z' _7 H" f8 K8 {6 M  r2 {         T *newData = new T[newCapacity];
        for( int i = 0 ; i < size ; i ++ ){
$ v8 M( I8 v& u% R              newData = data;
            }
2 W9 S. m3 X1 y, i3 `8 i. T3 b6 x        data = newData;
        capacity = newCapacity;
; l' n1 H' |0 _: a* R! q; ]+ o    }
public:
4 U3 \$ n6 k+ C( S    MyVector(){
1 t6 P0 `4 O0 f6 T        data = new T[100];
        size = 0;
        capacity = 100;
    }
    // 平均复杂度为 O(1)
2 H5 V& w, e" _" s# q) J    void push_back(T e){
  e# D6 M# w/ u0 l* v* a        if(size == capacity)
            resize(2 * capacity);
        data[size++] = e;
! x$ U$ `7 [, T! l9 ]$ e    }
    // 平均复杂度为 O(1)
    T pop_back(){
* e" P7 m# l/ i0 e3 {1 [% D        size --;
        return data[size];
    }
: O/ G2 z5 H" Q0 j+ p& b
};
; n* e; F4 \! o6 _1 V1 l
1 }1 \6 h( y' V
1
" d! u8 S" y" F# k2 k# t4 \2
7 V8 ^& c3 H0 n- q3
% M! h% c+ m3 R2 E4
5
1 v& _' a$ _" b2 t6
5 J+ ~9 u$ Z% O$ c* u- D7
7 `6 ?1 \0 a3 ]5 Q7 q7 r) N# h8
/ V* P- M$ T0 Q4 o9
10
* H2 r3 Q) G) w! U2 {11
( d, [# V2 U# W12
13
  x6 M4 Q6 x0 ]2 G4 e14
15
9 t  E% _6 C2 x3 O) Y9 A6 c; E3 V: J16
17
18
. \1 K( l) o5 Z3 I19
20
21
7 [5 ]* W! |6 r" t/ A( H% H' B22
" [( w% w2 Z2 W( G1 \23
- l' u/ u* V! T# i24
25
26
27
' I6 _7 }9 ]" ~" d28
29
8 B$ M1 N* d+ ?3 o  R  k30
31
32
/ H0 W6 B  L5 C: n5 r$ e, B33
  @& t$ u1 T$ p7 V6 Q" b. B+ d34
' e% \2 l: Z! r$ f35
push_back实现的功能是往数组的末尾增加一个元素，如果数组没有满，直接往后面插入元素；如果数组满了，即 size == capacity ，则将数组扩容一倍，然后再插入元素。
; D$ S9 q$ c* b( D5 Y
例如，数组长度为 n，则前 n 次调用 push_back 复杂度都为 O(1) 级别；在第 n + 1 次则需要先进行 n 次元素转移操作，然后再进行 1 次插入操作，复杂度为 O(n)。
5 I  W& ^& P. p/ Q; L# ^
因此，平均来看：对于容量为 n 的动态数组，前面添加元素需要消耗了 1 * n 的时间，扩容操作消耗 n 时间 ，
总共就是 2 * n 的时间，因此均摊时间复杂度为 O(2n / n) = O(2)，也就是 O(1) 级别了。

可以得出一个比较有意思的结论：一个相对比较耗时的操作，如果能保证它不会每次都被触发，那么这个相对比较耗时的操作，它所相应的时间是可以分摊到其它的操作中来的。

! I: F6 i% r$ j六、如何掌握好复杂度分析方法？
复杂度分析关键在于多练，所谓孰能生巧。
  {" G* V! m$ t. T
& F$ ]5 c3 n$ x5 O) A0 t1. 大O标记
3 e: H; Z: T- i5 b0 s从 CPU 的角度来看，这段代码的每一行都执行着类似的操作：读数据-运算-写数据。尽管每行代码对应的 CPU 执行的个数、执行的时间都不一样，但是，我们这里只是粗略估计，所以可以假设每行代码执行的时间都一样，为 单位时间（unit_time）。

算法运行工作量（基本操作重复执行的次数总和）的大小是数据规模 n 的函数，记作：f ( n ) 。

则代码执行时间可表示为：

T(n)=O(f(n))
1
大 O 时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势，O表示算法执行时间的增长率和 f ( n ) 的增长率相同，称为渐进时间复杂度，简称时间复杂度。

时间复杂度的基本原则：
; Q; U. I0 H1 J, r* N1 e+ z3 `
' Z4 D$ b  ?6 K; E; E0 l9 }只有常数项，认为其时间复杂度为O(1)
" s* F) S  M2 C顺序结构，时间复杂度按加法进行计算
( R9 z2 d: K- M( @' J$ Y8 J( Y  @循环结构，时间复杂度按乘法进行计算
# y0 {/ m* m. v4 i分支结构，时间复杂度取最大值
! r& y$ G' n4 S" g% u7 h判断一个算法的时间复杂度时，只需要关注最高次项，忽略最高次项的系数，且其它次要项和常数项也可以忽略
一般所分析的算法的时间复杂度都是指最坏时间复杂度
渐进式时间，空间复杂度分析只是一个理论模型，只能提供粗略的估计分析，我们不能直接就觉得O(logN)的算法一定优于O(n), 针对不同的宿主环境，不同的数据集，不同的数据量大小，在实际应用上面可能真正的性能会不同。

- u% O/ Y' V/ I* z  e9 T) X0 _总结
算法时间复杂度分析是一个很重要的问题，任何一个程序员都应该熟练掌握其概念和基本方法，而且要善于从数学层面上探寻其本质，才能准确理解其内涵。
. L) i3 N8 H# j% s4 u————————————————
版权声明：本文为CSDN博主「C君莫笑」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
& Q- Y& D* b2 Z" c! R# \& s% b; A原文链接：https://blog.csdn.net/qq_34623621/article/details/126768888
/ N% ]4 P; J! ?; H, E
, s; M! H& K3 F+ z' S  y; E$ U
8 M1 r; w$ d: \6 I