数据结构与算法之美--01时间复杂度分析

我不是女神ヾ 2022-03-06 11:14 223阅读 0赞

## 复杂度分析上 ##

听了极客时间的数据结构与算法之美课程后，受益匪浅，把一些我认为比较重要的知识点总结下来，虽然大部分是复制粘贴的。。。。。

数据结构与算法之美音频文件，需要的小伙伴们可以下载啊～  
[https://download.csdn.net/download/ayangann915/11033810][https_download.csdn.net_download_ayangann915_11033810]

\*\*时间复杂度：\*\*大O时间复杂度实际上并不具体表示代码真正的执行 时间，而是表示代码执行时间随数据规模增长的变化趋势，所以，也叫作渐进时间复杂度（asymptotic time complexity），简称时间复杂度。

**时间复杂度分析：**

*  只关注循环执行次数最多的一段代码
 *  加法法则：总复杂度等于量级最大的那段代码的复杂度
    
        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;
        
        }
    
     *  即便这段代码循环 10000 次、 100000 次，只要是一个已知的数，跟 n 无关，照样也是常量级的执行时间。当 n 无限大的时候，就可以忽略。尽 管对代码的执行时间会有很大影响，但是回到时间复杂度的概念来说，它表示的是一个算法执行效率与数据规模增长的变化趋势，所以不管常量的执行时间多 大，我们都可以忽略掉。因为它本身对增长趋势并没有影响。
     *  那第二段代码和第三段代码的时间复杂度是多少呢？答案是O(n)和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 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) 。 O(n)，所以，整个cal()函数的时间复杂度就是，T(n) = T1(n) \* T2(n) = O(n\*n) = O(n 2 )。

**常用复杂度量级：**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70]

我们可以粗略地分为两类，多项式量级和非多项式量级。其中，非多项式量级只有两个：O(2 n )和O(n!)。 当数据规模 n 越来越大时，非多项式量级算法的执行时间会急剧增加，求解问题的执行时间会无限增长。所以，非多项式时间复杂度的算法其实是非常低效的算 法。我们主要来看几种常见的多项式时间复杂度。

#### O(1): ####

O(1) 只是常量级时间复杂度的一种表示方法，并不是指只执行了一行代码。比如这段代码，即便有 3 行，它的时间复杂度也是 O(1 ）， 而不是 O(3) 。

int i = 8;
    int j = 6; 
    int sum = i + j;

只要代码的执行时间不随n的增大而增长，这样代码的时间复杂度我们都记作O(1)。或者说，一般情况下，只要算法中不存在循环语句、递归语 句，即使有成千上万行的代码，其时间复杂度也是Ο(1)。

#### O(logn)、O(nlogn) ####

对数阶时间复杂度非常常见，同时也是最难分析的一种时间复杂度。

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

根据前面讲的复杂度分析方法，第三行代码是循环执行次数最多的。

从代码中可以看出，变量 i 的值从 1 开始取，每循环一次就乘以 2 。当大于 n 时，循环结束。还记得我们高中学过的等比数列吗？实际上，变量 i 的取值就是一个等比 数列。如果我把它一个一个列出来，就应该是这个样子的：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 1]

我们只要知道x值是多少，就知道这行代码执行的次数了。通过2 x =n求解x这个问题我们想高中应该就学过了，我就不多说了。x=log 2 n，所以，这段代码的 时间复杂度就是O(log 2 n)。

再看下面的代码：

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

这段代码的时间复杂度为O(log 3 n)。

实际上，不管是以 2 为底、以 3 为底，还是以 10 为底，我们可以把所有对数阶的时间复杂度都记为 O(logn) 。

我们知道，对数之间是可以互相转换的，log 3 n就等于log 3 2 \* log 2 n，所以O(log 3 n) = O(C \* log 2 n)，其中C=log 3 2是一个常量。基于我们前面的一个理论：在采用 大O标记复杂度的时候，可以忽略系数，即O(Cf(n)) = O(f(n))。所以，O(log 2 n) 就等于O(log 3 n)。因此，在对数阶时间复杂度的表示方法里，我们忽略对数的“底”， 统一表示为 O(logn) 。

如果一段代码的时间复杂度是 O(logn) ，我们循环执行 n 遍，时间复 杂度就是 O(nlogn) 了。而且， O(nlogn) 也是一种非常常见的算法时间复杂度。比如，归并排序、快速排序的时间复杂度都是 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;
    }

从代码中可以看出， m 和 n 是表示两个数据规模。我们无法事先评估 m 和 n 谁的量级大，所以我们在表示复杂度的时候，就不能简单地利用加法法则，省略掉其中一 个。所以，上面代码的时间复杂度就是 O(m+n) 。 针对这种情况，原来的加法法则就不正确了，我们需要将加法规则改为： T1(m) + T2(n) = O(f(m) + g(n)) 。但是乘法法则继续有效： T1(m)\*T2(n) = O(f(m) \* f(n)) 。

### 空间复杂度分析 ###

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 2 )，像O(logn)、O(nlogn)这样的对数阶复杂度平时都用不到。而且，空间复杂度分析比时间复杂度分析要简单很多。

**内容小结：**

复杂度也叫渐进复杂度，包括时间复杂度和空间复杂度，用来分析算法执行效率与数据规模之间的增长关系，可以粗略地表示，越高阶复杂度的算法，执行效率 越低。常见的复杂度并不多，从低阶到高阶有：O(1)、O(logn)、O(n)、O(nlogn)、O(n 2 )。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 2]

## 复杂度分析（下）：浅析最好、最坏、平均、均摊时间复杂度 ##

四个复杂度分析方面的知识点，最好情况时间复杂度（best case time complexity）、最坏情况时间复杂度（worst case time complexity）、平均 情况时间复杂度（average case time complexity）、均摊时间复杂度（amortized time complexity）。

#### 最好、最坏情况时间复杂度 ####

int find(int[] array, int n, int x) {  
        int i = 0; 
        int pos = -1; 
        for (; i < n; ++i) {  
            if (array[i] == x)
                pos = i;
        } 
        return pos; 
    }

这段代码要实现的功能是，在一个无序的数组（ 段代码的复杂度是 O(n) ，其中， n 代表数组的长度。

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

要查找的变量 x 可能出现在数组的任意位置。如果数组中第一个元素正好是要查找的变量 x ，那就不需要继续遍历剩下的 n-1 个数据了，那时间复杂度就 是 O(1) 。但如果数组中不存在变量 x ，那我们就需要把整个数组都遍历一遍，时间复杂度就成了 O(n) 。所以，不同的情况下，这段代码的时间复杂度是不一样的。

为了表示代码在不同情况下的不同时间复杂度，我们需要引入三个概念：最好情况时间复杂度、最坏情况时间复杂度和平均情况时间复杂度。

顾名思义，**最好情况时间复杂度**就是，在最理想的情况下，执行这段代码的时间复杂度。就像我们刚刚讲到的，在最理想的情况下，要查找的变量x正好是数组的第一个元素，这个时候对应的时间复杂度就是最好情况时间复杂度。

同理，**最坏情况时间复杂度**就是，在最糟糕的情况下，执行这段代码的时间复杂度。就像刚举的那个例子，如果数组中没有要查找的变量x，我们需要把整个数组 都遍历一遍才行，所以这种最糟糕情况下对应的时间复杂度就是最坏情况时间复杂度。

#### 平均情况时间复杂度 ####

要查找的变量x在数组中的位置，有n+1种情况：在数组的0～n-1位置中和不在数组中。我们把每种情况下，查找需要遍历的元素个数累加起来，然后再除以n+1， 就可以得到需要遍历的元素个数的平均值，即：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 3]

我们知道，要查找的变量 x ，要么在数组里，要么就不在数组里。这两种情况对应的概率统计起来很麻烦，为了方便你理解，我们假设在数组中与不在数组中的概 率都为 1/2 。另外，要查找的数据出现在 0 ～ n-1 这 n 个位置的概率也是一样的，为 1/n 。所以，根据概率乘法法则，要查找的数据出现在 0 ～ n-1 中任意位置的概率就 是 1/(2n) 。

如果我们把每种情况发生的概率也考虑进去，那平均时间复杂度的计算过 程就变成了这样：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 4]

这个值就是概率论中的加权平均值，也叫作期望值，所以平均时间复杂度的全称应该叫加权平均时间复杂度或者期望时间复杂度。

引入概率之后，前面那段代码的加权平均值为(3n+1)/4。用大 O 表示法来表示，去掉系数和常量，这段代码的加权平均时间复杂度仍然是O(n)。

#### 均摊时间复杂度 ####

//实现向数组中插入数据的功能
    void insert(int val) { 
        if (count == array.length) {  
            int sum = 0; 
            for (int i = 0; i < array.length; ++i) {  
                sum = sum + array[i]; 
            } 
            array[0] = sum;
            count = 1; 
        }
        array[count] = val; 
        ++count;
    }

这段代码实现了一个往数组中插入数据的功能。当数组满了之后，也就是代码中的count == array.length时，我们用for循环遍历数组求和，并清空数组，将求和之后的 sum 值放到数组的第一个位置，然后再将新的数据插入。但如果数组一开始就有空闲空间，则直接将数据插入数组。

最理想的情况下，数组中有空闲空间，我们只需要将数据插入到数组下标为 count 的位置就可以了，所以最好情况时间复杂度为 O(1) 。

最坏的情况下，数组中没有空闲空间了，我们需要先做一次数组的遍历求和，然后再将数据插入，所以最坏情况时间复杂度为 O(n) 。

平均时间复杂度是是 O(1)。

假设数组的长度是 n ，根据数据插入的位置的不同，我们可以分为 n 种情况，每种情况的时间复杂度是 O(1) 。除此之外，还有一种 “ 额外 ” 的情况，就是在数组没有空 闲空间时插入一个数据，这个时候的时间复杂度是 O(n) 。而且，这 n+1 种情况发生的概率一样，都是 1/(n+1) 。所以，根据加权平均的计算方法，我们求得的平均时 间复杂度就是：  
![在这里插入图片描述][20190318201232169.png]

[https_download.csdn.net_download_ayangann915_11033810]: https://download.csdn.net/download/ayangann915/11033810
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70]: /images/20220303/134b024df67648f6b180c12dbdb4bd38.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 1]: /images/20220303/387e94a58a044e51a47f49662a5a1411.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 2]: /images/20220303/aac1feab43ee4a578208261473f4c4c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 3]: /images/20220303/de68bf77401e4de19a22f4d7b6e452d3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 4]: /images/20220303/062c2999e0894bbfb9fd6f10ad76faba.png
[20190318201232169.png]: /images/20220303/ae12b178bba641a68fd86b68d1531e36.png