在上一篇文章里，有看到一个简单算法题的2个解法，我们运用了复杂度分析来判断哪个解法更合适。
这里的复杂度，就是用于衡量程序的运行效率的重要度量因素。

虽然有句俗话“不管是白猫还是黑猫，抓到老鼠就是好猫”，这句话是站在结果导向的，没错。但是如果
有个程序要去处理海量数据，一个程序员写的要执行2天，而另一个程序员只要半小时，那么第二种显然更适合
我们的实际需求。

一、什么是复杂度

复杂度是一个关于输入数据量n的函数。

要表示复杂度很简单，用大写O加上括号O()将复杂度包起来就好了。比如这个代码的复杂度是f(n)，那就可以写成
O(f(n))。

在计算复杂度的时候，有三点需要我们记住：

• 复杂度与具体常系数无关
• 多项式级复杂度相加，选择高者为结果
• O(1)表示特殊复杂度

1、复杂度与具体常系数无关

举个例子，将一个列表反转，不用reverse()。

def demo_1():
    a = [1, 2, 3, 4, 5]
    b = [0 for x in range(0,5)]  #第一个for循环
    n = len(a)
    for i in range(n):   # 第二个for循环
        b[n - i - 1] = a[i]
    print(b)

if __name__ == "__main__":
    demo_1()

===============运行结果==================
D:\Programs\Python\Python36\python.exe D:/练习/leecode/fuzadu.py
[5, 4, 3, 2, 1]

Process finished with exit code 0

可以看到我先用了一个for循环创建了一个跟a列表等长度，元素全是0的列表。
然后再用一个for循环将a里的元素倒序放入b，最终得到一个跟a反序的列表。

其中，每一个for循环的时间复杂度都是O(n)，2个加起来就是O(n)+O(n)，也等于O(n+n)，也等于O(2n)。
也就是相当于 一段 O(n)复杂度的代码先后执行两遍，它们的复杂度是一致的。

2、多项式级复杂度相加，选择高者为结果

有了上面的例子，这个也就好理解了。
假设，一个算法的复杂度是O(n²)+O(n)，那么可以知道，当n越来越大，也就是输入的数据量越来越大时，n^2的变化率要比n大的多，
所以，这时候我们只取变化率更大的n^2来表示复杂度即可，也就是O(n²)+O(n)等同于O(n²)。

3、O(1)表示特殊复杂度

还是借助上面的反转问题，这里再使用第二种解法。

def demo_2():
    a = [1, 2, 3, 4, 5]
    tmp = 0
    n= len(a)

    for i in range(n//2):    #  // 表示整数除法，返回不大于结果的一个最大整数
        tmp = a[i]
        a[i] = a[n -i -1]
        a[n -i -1] = tmp
    print(a)

if __name__ == "__main__":
    demo_2()

==============运行结果==============
D:\Programs\Python\Python36\python.exe D:/练习/leecode/fuzadu.py
[5, 4, 3, 2, 1]

Process finished with exit code 0

跟第一个解法相比，第二个解法少了一个for循环，而且循环次数只是到了列表的一半，那么时间复杂度就是O(n/2)，
由于复杂度与具体的常系数无关的性质，这段代码的时间复杂度还是 O(n)。

但是在空间复杂度上，第二个解法开辟了一个新的变量tmp，它与数组长度无关。
输入是 5 个元素的数组，需要一个tmp变量输入是 50 个元素的数组，同样只需要一个tmp变量。

因此，空间复杂度与输入数组长度无关，这就是 O(1)。

二、分析复杂度

这里就直接上一些经验性的结论，可以直接拿过来用的：

• 一个顺序结构的代码，时间复杂度是 O(1)。
• 一个简单的 for 循环，时间复杂度是 O(n)。
• 两个顺序执行的 for 循环，时间复杂度是 O(n)+O(n)=O(2n)，其实也是 O(n)。
• 两个嵌套的 for 循环，时间复杂度是 O(n²)。
• 二分查找，时间复杂度都是 O(logn)。

趁热打铁，分析一下下面代码的复杂度：

for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
        for (k = 0; k < n; k++) {
        }
        for (m = 0; m < n; m++) {
        }
    }
}

可以先从最里面看，最内层是2个顺序结构的for循环，复杂度是O(n)。
中间这层的又嵌套了一个for循环，所以这时候复杂度就变成了O(n^2)。
最后，最外层又嵌套了一个for循环，所以最终的复杂度就是O(n^3)。

虽然测试工程师的代码对于复杂度要求不高甚至说非常低，但是我觉得理解复杂度，并且会做一些简单的分析
还是很有必要的。