算法的时间&空间复杂度

算法效率的评估

解决一个问题可能有很多种方法，类似要排序一个数组就有：冒泡、选择、快排&归并排序等。 那么这些算法效率有高有低，如何衡量？指标就是时间复杂度和空间复杂度----分别代表了实现该算法的程序需要消耗的时间和内存空间。

算法时间复杂度

算法执行时间在不同语言实现、不同机器环境运行都不一致；很难精确计算实际耗时。而通常我们只需要一个简单的方式来简易评估程序大概运行耗时，再通俗点就是程序跑完算法要执行语句的次数。需要更专业的解释戳知乎：https://www.zhihu.com/question/21387264

通常时间复杂度用一个Big O表示法，类似O(1)、O(n)、O(n²)等，即用一个函数来描述算法的语句执行频度。Big O表示法会忽略函数的系数，类似O(n)即代表一个算法具有 y=kx 线性函数复杂度，随着输入n的变化执行次数呈现线性函数的增长曲线。

常见的时间复杂度

常数级O(1)

    var age = 20;
    println("Hello World")
    println("Hi, Joker")
   /**这里无论写多少句，只要不牵扯到循环之类的随变量变化而不确定执行次数的case，都属于O(1)常数阶，执行次数为一个确定常数
  **/

线性级O(n)

    var count = 20; //这里的count是指外部输入的变量 并非给定常数
    println("Hello World")
    val range = 1 until count
    for(num in range){
       println("Hi, Joker")
    }
   /**最简单的加上一句for循环,这段代码执行次数会根据count的变化而呈现线性增长
  **/

这里若是将val range = 1 until count --> val range = 1 until 3*count 虽然变成了y=3x但依然是个线性也是O(n）

平方级O(n²)

    var count = 20; //这里的count是指外部输入的变量 并非给定常数
    println("Hello World")
    val range = 1 until count
    for(num in range){
        for(inex in range){
            println("Hi, Joker")
        }
    }
   /**最简单平方阶代表是双层循环**/

拓展思考下面的代码是什么级的时间复杂度？

    val count = 5 //ex count = 5, count指代指外部输入的变量n
    println("Hello World")
    for( i in 1..count) {
        for( j in i..count){
            println("Hi, Joker.")
        }
    }
//这段代码最终的执行次数为 1+2+3+4+5  --》 
1+2+3+....+n = (n+1)*n/2 = 0.5*n² + 0.5*n ---> 忽略系数还是O(n²)

对数级O(logn)

    var count = 8; //这里的count是指外部输入的变量 并非给定常数
    println("Hello World")
    var index = 1
    while( index < count ){
        println("Hi, Joker")
        index = index * 2 //以2为基数累乘
    }
/** 循环次数y=log₂n 为对数关系O(logn)**/

指数阶

//指数阶的算法性能效率属于较低了，最常见于递归：比如斐波那契数列的递归写法。

fun main() {
   //斐波那契数列 0、1、1、2、3、5、8、13...... (n>=1）
    println(fib(7))
}
fun fib(n: Int): Int {
    if(n <= 1) return n
    return fib(n-1) + fib(n-2)
}

Ex:计算fib(7) --> fib(6)+fib(5)
fib(6) --> fib(5)+fib(4)
fib(5) --> fib(4)+fib(3)
每一个函数调用都会触发两个新的函数调用，用树形结构表示：

可以看到树形结构每增加一层节点数就是上一层的2倍而且会计算很多重复的节点值。按照树形图若要完整递归计算出fib(7)需要7层，从fib(7)--> fib(1)需要call 函数2^7 次， 所以属于指数阶复杂度O(2^n)

常见时间复杂度对比

O(1)<O(logn)<O(n)<O(nlogn)<O(n²)<O(2ⁿ)<O(n!)

常见算法的复杂度

二分查找 ---> O(logn)
归并排序（merge sort） ---> O(nlogn)

节点数总数为n的下列算法：
树的前序、中序、后续遍历 --> O(n)
搜索算法：DFS、BFS --> O(n)
图的遍历 ---> O(n)

换个角度看这几个算法都是有且仅访问一次节点的算法，所以时间复杂度都为O(n)

空间复杂度

关于空间复杂度类似的就用来评估程序对内存空间的使用情况，粗暴是只考虑程序运行期间额外申请消耗的最大内存规模：
这里的额外指的是除了程序本身的指令存储空间以及存储输入数据需要的空间等与算法本身无关的空间消耗：通常是动态申请的数组空间、临时变量、递归函数栈空间等

比如算法需要申请了一个长度为n的一维数组来解决问题 ---> O(n)
或者需要申请一个n*n的二维数组，那么就是O(n^2)
另外就是使用递归的情况基本相当于递归树的层数，上述斐波拉契的算法递归层级为N ---> O(n)

为啥递归的空间复杂度是递归树的层数？

递归斐波那契空间分析

由函数递归调用顺序来看，每次递归虽然会产生两次新的函数调用但是由于加法优先级，会先计算左边的操作数，从fib(5)一直先call到fib(1)，然后fib(1)计算完成返回值销毁回收自己的函数栈空间往回调用。所以消耗最大的内存就是最深的调用层级n*S(S代表每次调用函数消耗的函数栈空间) ，即递归空间复杂度等于递归函数最深的层数级。

参考信息

CSDN博文 算法（一）时间复杂度
如何理解算法时间复杂度的表示法，例如 O(n²)、O(n)、O(1)、O(nlogn) 等？