什么是算法

百度百科对算法的定义是“解题计划的精确而残缺的形容，是一系列解决问题的清晰指令，算法代表着用零碎的办法形容解决问题的策略机制。”

简略的来讲，算法就是解决一个问题所用的办法。比方对于数组排序问题，有多种排序办法能够达到使元素有序排列的目标，每一种正确的排序办法都能称之为一个算法。

如何掂量算法的好坏

一个问题既然能够通过多种算法来解决，那么如何掂量哪个算法更好呢？显然一个算法执行工夫越短，占用的内存空间越小，那么它就是更好的算法。通常有两种办法来比拟：事先剖析和预先统计。预先统计就是指先编写好算法，并运行监控其指标，该办法的问题在于受运行环境、电脑硬件烦扰，会覆盖算法自身的优劣。因而迷信的办法是通过数学分析的办法来评估算法的好坏。

后面说到算法执行工夫越短，占用内存空间越小，算法越好。对应的，咱们经常用工夫复杂度来代表算法执行工夫，空间复杂度代表算法占用的内存空间。

工夫复杂度

一般来讲，一个算法破费的工夫与其中执行的语句的次数成正比，一个算法中的语句执行次数称为 工夫频度，用 T(n) 来示意。比方有 func 函数如下：

function func(n) {for(let i = 0; i < n; i ++) {       // 执行 n + 1 次
        console.log('Hello World!')     // 执行 n 次
    }
    return                              // 执行 1 次
}

对于 func 来讲，该算法运行时，共执行了 2n+2 次运算，那么该算法的工夫频度 T(n) = 2n + 2, n 为算法输出的大小，即输出的数据规模，当 n 一直变动时，T(n) 也会随之变动。

假如有某个辅助函数 f(n), 当 n 趋于无穷大时，总有 T(n) <= C f(n) (C 为常数) 成立，即 T(n) 的上界是 C f(n)，记作 T(n) = O(f(n))，称 O(f(n)) 为算法的渐进工夫复杂度，O 示意正比例关系，f(n) 示意代码执行次数之和，这种示意办法叫做「大 O 符号表示法」。

所以对于函数 func 来讲，有 T(n) = O(2n+2)，能够简化为 T(n) = O(n)。为什么能够简化呢，是因为大 O 表示法只是用来代表执行工夫的增长变化趋势，当 n 无穷大时，2n+2 中的常量就没有意义了，同时因为符号 O 中暗藏着常数 C，所以 n 的系数 2 能够省略到 C 中。f(n) 中 n 个别不加系数。同理，咱们能够失去 O(2n²+n+1) = O(2n²) = O(n²)。如果把 T(n) 示意成一棵树，O(f(n)) 示意的就是树干，其余的细枝末节对于复杂度的影响远小于树干。

一般来讲，掂量一个算法的复杂度，咱们往往只须要判断循环构造里基本操作产生了多少次，就能代表该算法的工夫复杂度。

常见的工夫复杂度：

• 常数阶 O(1)

加减乘除 (eg. i++，i–)、数组寻址(eg. array[10])、赋值操作(eg. a=1) 等都属于常数级的复杂度，简言之如果没有循环等简单构造，不随输出数量级 n 变动的操作，该代码的工夫复杂度都属于常数级复杂度，不论这种代码有多少行。

• 对数阶 O(logn)

function func(n) {
    let i = 0;
    while(i < n) {i *= 2;}
}

对如上 func 函数来讲，在 while 循环中，假如当循环到第 m 次时，有 i = n，即 2 的 m 次方等于 n，可知 m = logn (往往将以 2 为底省略)，即 while 循环内的操作运行了 logn 次，该算法的工夫复杂度即为 logn。

• 线性阶 O(n)

function func(n) {
    sum = 0;
    for(let i = 0; i < n; i++) {sum += i;}
    return sum; 
}

如上 func 函数，for 循环中的原子操纵执行了 n 次，该算法的工夫复杂度即为 O(n)。

• 线性对数阶 O(nlogn)

function func(n) {for(let m = 1; m < n; m++)
    {
        let i = 1;
        while(i < n)
        {i = i * 2;}
    }
}

如上函数，有双层循环构造，显然依据之前的工夫复杂度能够推断进去该算法的工夫复杂度为 O(nlogn)，当然下面的函数是为了凑这个复杂度而凑的，并没有理论的意义。

• 平方阶 O(n²)

function func(n) {
    let sum = 0;
    for(let i = 0; i < n; i ++) {for(let j = 0; j < n; j ++) {sum += i * j;}
    }
    return sun;
}

如上函数，有双层循环构造，第 5 行代码，共循环运行了 n² 次，所以该算法的工夫复杂度为 O(n²)。

• 立方阶 O(n³)，K 次方阶 O(n^k)

和平方阶同理，有多层循环构造，该循环构造中的原子操作循环的次数。

常见的算法工夫复杂度由小到大顺次为：Ο(1)<Ο(logn)<Ο(n)<Ο(nlogn)<Ο(n²)<Ο(n³)<…<Ο(2^n)<Ο(n!)。

空间复杂度

空间复杂度是对一个算法在运行过程中辅助变量长期占用存储空间大小的一个量度。空间复杂度和工夫复杂度同理，也采纳大 O 表示法，比拟罕用的有：O(1)、O(n)。

• O(1)

算法执行时所须要的长期空间不随着数据规模 n 的大小变动，则算法的空间复杂度为 O(1)，比方对于数组求和，其中 sum 和 i 都是长期变量，所须要的空间不随 array 长度的大小而变动，所以该函数的空间复杂度为 O(1)。

function func(array) {
    let sum = 0;
    for(let i = 0; i < array.length; i++) {sum += array[i];
    }
    return sum;
}

• O(n)

function func(array) {let new_array = [...array];
    return new_array;
}

如上函数是复制了输出 array 数组，返回复制的数组，在函数中，创立了 array.length 长度的新数组 new_array，该算法的空间复杂度和原数组 array 的长度成正比，故该算法的工夫复杂度为 O(n)，n 代表数组 array 的长度。

至此咱们曾经理解了常见的工夫复杂度和空间复杂度，工夫复杂度的剖析须要依据具体的算法来剖析，有了这个根底，咱们就能针对实际的算法进行剖析啦！

参考

https://www.zhihu.com/question/21387264

https://zhuanlan.zhihu.com/p/50479555

https://www.jianshu.com/p/f4cca5ce055a

https://blog.csdn.net/zolalad/article/details/11848739

文|hustlmn

关注得物技术，携手走向技术的云端