复杂度分析(上)

1什么是复杂度分析?

分别用时间复杂度(执行的快慢)和空间复杂度(内存的消耗 )两个概念来描述性能问题，二者统称为复杂度.

复杂度就是用来分析算法执行效率与数据规模之间增长关系。

2.为什么要进行复杂度分析?

1.和性能测试相比，复杂度分析有不依赖执行环境、成本低、效率高、易操作、指导性强的特点。
2.掌握复杂度分析，将能编写出性能更优的代码，有利于降低系统开发和维护成本。　

3.如何进行数据结构和算法的复杂度分析?

1.大O表示法
1）来源
算法的执行时间与每行代码的执行次数成正比，用T(n) = O(f(n))表示，其中T(n)表示算法执行总时间，f(n)表示每行代码执行总次数，而n往往表示数据的规模。
2）特点
以时间复杂度为例，由于时间复杂度描述的是算法执行时间与数据规模的增长变化趋势，所以常量阶、低阶以及系数实际上对这种增长趋势不产决定性影响，所以在做时间复杂度分析时忽略这些项。
2.复杂度分析法则
1）单段代码看高频(只关注循环执行次数最多的一段代码)：比如循环。

1　　int cal(int n) {
2　　int sum = 0;
3　　int i = 1;
4　　for (; i <= n; ++i) {
5　　sum = sum + i;
6　　}
7　　return sum;
8　　}

其中第 2、3 行代码都是常量级的执行时间，与 n 的大小无关.4、5两行为循环执行次数最多的一段代码,

这两行代码执行了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) {
10　　sum_2 = sum_2 + q;
11　　}
12
13　　int sum_3 = 0;
14　　int i = 1;
15　　int j = 1;
16　　for (; i <= n; ++i) {
17　　j = 1;
18　　for (; j <= n; ++j) {
19　　sum_3 = sum_3 + i * j;
20　　}
21　　}
22
23　　return sum_1 + sum_2 + sum_3;
24　　}

其中的4、５两行执行了１００次，与ｎ无关．

段代码循环 10000 次、100000 次，只要是一个已知的数(常量,与n无关),就可以忽略.因为时间复杂度表示的是一个算法执行效率

与数据规模增长的变化趋势.所以不管常量的执行时间对增长趋势并没有影响.

９、１０两段代码的时间复杂程度是O(n),１６、１７、１８、１９的时间复杂程度是O(n2)．所以这段代码的时间复杂程度是O(n2)．

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

第 4～6 行的时间复杂度就是，T1(n) = O(n)．但第五行的 f(i)函数本身就是 O(n)，所以整个函数的复杂程度就是

T(n) = T1(n) * T2(n) = O(n*n) = O(n2)。

四、常用的复杂度级别
多项式阶：随着数据规模的增长，算法的执行时间和空间占用，按照多项式的比例增长。包括，
O(1)（常数阶）、O(logn)（对数阶）、O(n)（线性阶）、O(nlogn)（线性对数阶）、O(n^2)（平方阶）、O(n^3)（立方阶）
非多项式阶：随着数据规模的增长，算法的执行时间和空间占用暴增，这类算法性能极差。包括，
O(2^n)（指数阶）、O(n!)（阶乘阶）

1. O(1)

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

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

它的时间复杂度也是O(1），而不是 O(3)。

2. O(logn)、O(nlogn)

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

这段代码ｉ＜＝ｎ时结束，那么就是２的ｉ次方＝Ｎ．求得时ｉ的值．则x=log2n．时间复杂度就是 O(log2n)。

但是对数是可以相互转换的．例如log3n 就等于 log32 * log2n．所以 O(log3n) = O(C * log2n)，其中C=log32 是一个常量．

在采用大 O 标记复杂度的时候，可以忽略系数，即 O(Cf(n)) = O(f(n))。所以，O(log2n) 就等于 O(log3n)。

因此，在对数阶时间复杂度的表示方法里，我们忽略对数的“底”，，统一表示为 O(logn)。

那么O(nlogn)就是循环执行一段时间复杂程度是O(logn)的代码．

3. 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))。

空间复杂度分析

空间复杂度全称就是渐进空间复杂度（asymptotic space complexity），表示算法的存储空间与数据规模之间的增长关系。

１　　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]
９　　}
１０　}

第３行申请了一个大小为ｎ的int类型数组．其他的代码没有占用更多的空间．所以整段代码的复杂程度就是O(n)

上面说了这么多,但是没有真正的用到有时候就不会真正的理解.所以想要真正的想要理解复杂分析度还是要多加练习.

本文是在学习王争老师的数据结构与算法之美的笔记.有些是王争老师或者评论的言语.在此附上原文链接

 https://time.geekbang.org/column/article/40036