算法了解一下，是什么？有哪些？

算法简介

什么是算法

算法 是，对特定问题求解方法和步骤的一种描述。它是有限指令的有限序列，其中每个指令表示一个或多个操作。

算法与程序的比较

• 算法是解决问题的一种方法或一个过程，考虑如何将输入转换成输出，一个问题可以有多种算法。
• 程序是用某种程序设计语言对算法的具体实现。
• 程序 = 数据结构 + 算法

算法的特性

一个算法必须具备以下五个重要特性：

• 有穷性 ：一个算法必须总是在执行有穷步之后结束，且每一步都在有穷时间内完成。
• 确定性 ：算法中每一条指令必须有确切的含义，没有二义性，在任何条件下只有唯一的一条执行路径，即对相同的输入只能得到相同的输出。
• 可行性： 算法是可执行的，算法描述的操作可以通过已经实现的基本操作执行有限次来实现。
• 输入 ：一个算法有零个或n个输入
• 输出 ：一个算法有一个或n个输出

算法设计要求

算法设计的基本要求（好的算法的要求）：

• 正确性（Correctness）：应满足具体问题的需求。
• 可读性（Readability）：应容易供人阅读和交流，方便理解和修改。
• 健壮性（Robustness）：应具有容错处理。当输入非法或错误数据时，算法应能适当地作出反应或进行处理，而不会产生莫名其妙的输出结果。
• 通用性（Generality）：算法应具有一般性 ，即算法的处理结果对于一般的数据集合都成立。
• 高效性（Efficiency）：效率与存储空间需求： 效率指的是算法执行的时间；存储空间需求指算法执行过程中所需要的最大存储空间。一般这两者与问题的规模有关。

一个好的算法首先要具备正确性，然后是健壮性，可读性，在几个方面都满足的情况下，主要考虑算法的效率，通过算法的效率高低来评判不同算法的优劣程度。

---

算法分析

什么是算法分析？

当我们说算法分析的时候我们在说什么？（狭义的技术层面的定义）：

算法分析指的是：对算法在运行时间和存储空间这两种资源的利用效率进行研究。

即时间效率和空间效率。

时间效率指算法运行有多快；

空间效率指算法运行时需要多少额外的存储空间。

（时间效率也叫时间复杂度；空间效率也叫空间复杂度。）

在计算机时代早期，时间和空间这两种资源都是及其昂贵的。但经过半个多世纪的发展，计算机的速度和存储容量都已经提升了好几个数量级。

现在空间效率已经不是我们关注的重点了，但时间效率的重要性并没有减弱到这种可以忽略的程度。

算法分析通用思路

1. 输入规模

   首先第一步考虑这个算法的输入规模是什么？即输入参数，再换句话说也就是待解决的问题有多大？

   从这里入手是因为一个显而易见的规律就是，不管使用什么算法，输入规模越大，运行效率肯定会更长。

   输入规模的确定要根据具体要解决的实际问题的细节来决定，相同的问题不同的细节，输入规模是不一样的。比如：一个拼写检查的算法，

   如果算法关注的是单独的字符检查，那么字符的数量就是输入规模的大小；

   如果算法关注的是词组搭配的检查，那么这个输入规模就要比单独的字符检查的输入规模要小，这里输入规模就是词的数量了。

2. 运行时间的度量单位

   第二步考虑这个算法的运行时间，即这个算法运行地快慢。

   我们可以简单地用计时的方法，即某个算法运行了多少毫秒。

   但这个方式有一个缺陷就是在不同计算机上，相同算法的运行时间是不一样，因为有的电脑快有的电脑慢。

   所以有没有一种度量方法可以排除这些无关因素？

   答案是肯定的，我们可以关注算法执行了多少步，即操作的运行次数。而且为了简化问题我们只需关注最重要的操作步骤，即所谓的基本操作，因为基本操作已经足够可以决定这个算法的品质。

   比如一个算法通常是最内层的循环中是最费时的操作，那我们就只需要把它循环了多少次作为基本操作进行研究。

3. 增长次数

   这里需要延伸的一点是在大规模的输入情况下考虑执行次数的增长次数。因为针对小规模的输入，在运行时间的差别上不太明显。比如只对100个数字进行排序，不管你用什么排序算法，时间效率都差不多。只有在输入规模变大的时候，算法的差异才变得既明显又重要了起来。

   简单来说，

   1. 如果一个算法在输入规模变大时，但运行时间平缓增长，那么我们就可以说它就是一个效率高的算法；
   2. 而如果一个算法在输入规模变大时，它的运行时间成指数级增长，那就可以说这个算法的效率很差。

   总而言之就是，对基本操作的大规模输入情况下的变化的研究才更具有深远意义。

4. 算法的最优、最差和平均效率

   当我们了解了输入规模对算法时间效率的会产生影响，但算法的执行效率却不仅仅只受输入规模的影响，某些情况下，算法的执行效率更取决于输入参数的细节。

   比如：一个简单的顺序查找的算法，在数组里查找数字 9：

   在数组 list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9] 里查找数字 9 和在相同的输入规模的另一个数组 list2 = [9, 1, 2, 3, 4, 5, 6, 7, 8]里查找数字 9，在数组 list2 的执行效率肯定更高。

   上面小例子中的两个数组就体现了两个极端：输入最优情况和输入最坏情况。

   相对应的，

   在输入最优情况下的算法就叫最优效率；

   在输入最坏情况下的算法就叫最差效率；

   在这里有两个经验性的规则：

   1. 最优效率的分析远远不如最差效率分析重要（因为最差效率可以确定算法运行时间的上界）；
   2. 如果一个算法的最优效率都不能满足我们的要求，那么我们就可以立即抛弃它。

   在现实情况下，输入是“随机”的，既不会是最优输入也不会是最坏输入。所以这里又要引出一个概念，即：平均效率。

   首先指出，我们绝不能用“最优效率”和“最差效率”的平均数求得平均效率，即便有时候这个平均数和真正的平均效率巧合地一致。

   正确的步骤是：我们要对输入规模 n 做一些假设。

   对于上面的顺序查找算法的例子，标准的假设有两个：

   1. 输入里包含目标数字，那么算法会成功查找到目标数字，此时，成功查找概率是 p(0 <= p <= 1)；
   2. 对于任意数字 i，匹配发生在列表的第 i 个位置的概率是相同的。

   基于这两个假设求平均效率可得：

   1. 成功查找到目标的情况下，对于任意 i，第一次匹配发生在第 i 个位置的概率都是 p/n，此时，算法所做的比较次数是 i；
   2. 输入数组里不包含目标数字，那么算法不成功查找，比较次数是 n，在这种情况下，可能性是 (1-p)。

   由此，平均效率 C(n) = p(n+1) / 2 + n(1-p)

   C(n) = [1 * p/n + 2 * p/n + … + i * p/n + … + n * p/n] + n*(1-p)

   = p/n[1 + 2 + … + i + … + n] + n(1-p)

   = p/n * n(n+1)/2 + n(1-p)

   = p(n+1) / 2 + n(1-p)

   由此可知，

   1. 如果 p = 1，也就是说成功率是 100%，查找一定能成功，代入公式可得 (n+1)/2，即大约要查找数组中一半的元素；
   2. 如果 p = 0，也就是说成功率是 0%，查找必定失败，代入公式可得 n，即算法会对所有元素全部查找一遍。

   从这个例子可以发现，平均效率的研究要比最差效率和最优效率的研究困难很多：

   我们要将输入规模 n 划分为几种类型，对于同类型的输入，使得算法的执行次数是相同的。

算法的复杂度

什么是算法的复杂度

算法复杂度是指算法在编写成可执行程序后，运行时所需要的资源，资源包括时间资源和内存资源。应用于数学和计算机导论。

算法复杂度的表示

• 大Ω：最好的情况。大Ω的算法描述了如何快速算法可以在最好的情况下运行。

  f(x) = Ω(g(x)) 表示的含义是f(x)以g(x)为下界

• 大O：最坏的情况。通常，我们最关心的是大O时间，因为我们最关心的是给定算法的运行速度。我们如何使最坏情况不像它可能的那么糟呢?

  f(x) = O(g(x)) 表示的含义是f(x)以g(x)为上界

• 大θ：这只能被用来描述一个算法的运行时如果大Ω, 大O都是相同的。也就是说，算法的运行时间在最好和最坏的情况下都是相同的。

  f(x) = Θ(g(x)) 表示的含义是g(x)是f(x)的确界

算法的时间复杂度

算法中基本操作重复执行的次数是问题规模n的某个函数，其时间量度记作：T(n)=O(f(n))，称作算法的渐近时间复杂度（Asymptotic Time complexity），简称时间复杂度。一般地，常用最深层循环内的语句中的原操作的执行频度（重复执行的次数）来表示。

表示时间复杂度的阶有：

• O(1)：常量时间阶
• O(n)：线性时间阶
• O(logn)：对数时间阶
• O(n*logn)：线性对数时间阶
• O (n^k)：k≥2，k次方时间阶

时间复杂度实例讲解

例：两个n阶方阵的乘法

/* O(n^3) */
for (int i = 0; i < n; i++) {
    for (int j = 0; j < n: j++) {
        c[i][j] = 0;
        for (int k = 0; k < n; k++) {
            c[i][j] += a[i][k] * b[k][j];
        }
    }
}

由于是一个三重循环，每个循环从1到n，则总次数：n * n * n=n³ ，时间复杂度为T(n)=O(n^3)。

基本操作执行次数 T(n)

关于代码的基本操作执行次数，我们用四个生活中的场景来做一下比喻：

场景1. 给小灰一条长10寸的面包，小灰每3天吃掉1寸，那么吃掉整个面包需要几天？

答案自然是 3 X 10 = 30天。

如果面包的长度是 N 寸呢？

此时吃掉整个面包，需要 3 X n = 3n 天。

如果用一个函数来表达这个相对时间，可以记作 T（n） = 3n。

场景2. 给小灰一条长16寸的面包，小灰每5天吃掉面包剩余长度的一半，第一次吃掉8寸，第二次吃掉4寸，第三次吃掉2寸…那么小灰把面包吃得只剩下1寸，需要多少天呢？

这个问题翻译一下，就是数字16不断地除以2，除几次以后的结果等于1？这里要涉及到数学当中的对数，以2位底，16的对数，可以简写为log16。

因此，把面包吃得只剩下1寸，需要 5 X log16 = 5 X 4 = 20 天。

如果面包的长度是 N 寸呢？

需要 5 X logn = 5logn天，记作 T（n）= 5logn。

场景3. 给小灰一条长10寸的面包和一个鸡腿，小灰每2天吃掉一个鸡腿。那么小灰吃掉整个鸡腿需要多少天呢？

答案自然是2天。因为只说是吃掉鸡腿，和10寸的面包没有关系 。

如果面包的长度是 N 寸呢？

无论面包有多长，吃掉鸡腿的时间仍然是2天，记作 T（n）= 2。

场景4. 给小灰一条长10寸的面包，小灰吃掉第一个一寸需要1天时间，吃掉第二个一寸需要2天时间，吃掉第三个一寸需要3天时间…每多吃一寸，所花的时间也多一天。那么小灰吃掉整个面包需要多少天呢？

答案是从1累加到10的总和，也就是55天。

如果面包的长度是 N 寸呢？

此时吃掉整个面包，需要 1+2+3+…+ n-1 + n = (1+n)*n/2 = 0.5n^2 + 0.5n。

记作 T（n）= 0.5n^2 + 0.5n。

上面所讲的是吃东西所花费的相对时间，这一思想同样适用于对程序基本操作执行次数的统计。刚才的四个场景，分别对应了程序中最常见的四种执行方式：

场景1， T（n） = 3n，执行次数是线性的。

场景2， T（n） = 5logn，执行次数是对数的。

场景3，T（n） = 2，执行次数是常量的。

场景4，T（n） = 0.5n^2 + 0.5n，执行次数是一个多项式

渐进时间复杂度 O(f(n))

有了基本操作执行次数的函数 T（n），是否就可以分析和比较一段代码的运行时间了呢？还是有一定的困难。

比如算法A的相对时间是T（n）= 100n，算法B的相对时间是T（n）= 5n^2，这两个到底谁的运行时间更长一些？这就要看n的取值了。

所以，这时候有了 渐进时间复杂度（asymptotic time complectiy） 的概念，官方的定义如下：

若存在函数 f(n)，使得当n趋近于无穷大时，T(n) / f(n)的极限值为不等于零的常数，则称 f(n)是T(n) 的同数量级函数。

记作 T(n)= O(f(n))，称 O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。

渐进时间复杂度用大写O来表示，所以也被称为大O表示法。

如何推导出时间复杂度呢？有如下几个原则：

1. 如果运行时间是常数量级，用常数1表示。
2. 只保留时间函数中的最高阶项
3. 如果最高阶项存在，则省去最高阶项前面的系数。

让我们回头看看刚才的四个场景。

场景1：

T（n） = 3n

最高阶项为3n，省去系数3，转化的时间复杂度为：

T（n） = O（n）

场景2：

T（n） = 5logn

最高阶项为5logn，省去系数5，转化的时间复杂度为：

T（n） = O（logn）

场景3：

T（n） = 2

只有常数量级，转化的时间复杂度为：

T（n） = O（1）

场景4：

T（n） = 0.5n^2 + 0.5n

最高阶项为0.5n^2，省去系数0.5，转化的时间复杂度为：

T（n）= O（n^2）

这四种时间复杂度究竟谁用时更长，谁节省时间呢？稍微思考一下就可以得出结论：

O（1）< O（logn）< O（n）< O（n^2）

在编程的世界中有着各种各样的算法，除了上述的四个场景，还有许多不同形式的时间复杂度，比如：

O（nlogn）, O（n^3）, O（m\n），O（2^n），O（n！）

其关系为：

O(1) < O(logn) < O(n) < O(n*logn) < O(n^2) < O(n^3)

指数时间的关系为：

O(2^n) < O(n!) < O(n^n)

当n取得很大时，指数时间算法和多项式时间算法在所需时间上非常悬殊。因此，只要有人能将现有指数时间算法中的任何一个算法化简为多项式时间算法，那就取得了一个伟大的成就。

对于不同运行时间的快速图形表示以及它们之间的比较，大O cheatsheet也非常有用。

时间复杂度的巨大差异

我们来举一个栗子：

算法A的相对时间规模是T（n）= 100n，时间复杂度是O(n)

算法B的相对时间规模是T（n）= 5n^2 ，时间复杂度是O(n^2)，

算法A运行在小灰家里的老旧电脑上，算法B运行在某台超级计算机上，运行速度是老旧电脑的100倍。

那么，随着输入规模 n 的增长，两种算法谁运行更快呢？

从表格中可以看出，当n的值很小的时候，算法A的运行用时要远大于算法B；当n的值达到1000左右，算法A和算法B的运行时间已经接近；当n的值越来越大，达到十万、百万时，算法A的优势开始显现，算法B则越来越慢，差距越来越明显。

这就是不同时间复杂度带来的差距。

算法的空间复杂度

空间复杂度（Space complexity）：是指算法编写成程序后，在计算机中运行时所需存储空间大小的度量。
记作：S(n) = O(f(n))，其中：n为问题的规模或大小。

存储空间一般包括三个方面：

• 输入数据所占用的存储空间；
• 指令常数变量所占用的存储空间；
• 辅助（存储）空间。

一般地，算法的空间复杂度指的是辅助空间。如：

• 一维数组a[n]：空间复杂度 O(n)
• 二维数组a[n][m]：空间复杂度 O(n*m)

例如

int i = 1;
int j = 2;
++i;
j++;
int m = i + j;

变量 i、j、m 所分配的空间都不随着处理数据量变化，因此它的空间复杂度 S(n) = O(1)

如果算法执行所需要的临时空间不随着某个变量n的大小而变化，即此算法空间复杂度为一个常量，可表示为 O(1)。

int[] m = new int[n]
for(i=1; i<=n; ++i)
{
   j = i;
   j++;
}

这段代码中，第一行new了一个数组出来，这个数据占用的大小为n，这段代码的2-6行，虽然有循环，但没有再分配新的空间，因此，这段代码的空间复杂度主要看第一行即可，即 S(n) = O(n)

常见的算法复杂度

上图横轴代表输入规模，数轴代表复杂度，由图中的时间复杂度增长趋势可以看出:

• 常见的最优的算法复杂度为logN；
• 当 N 的值较小时，NlogN < N, 当 N 的值较大时，NlogN > N；
• 指数次方与阶乘的复杂度非常高，应当尽量避免使用这些算法，二次方或三次方的时间复杂度在N值较大是也是相当高的，在设计算法的时候必须要注意这一点；

---

算法总览

算法的基石：

• branch：if-else，switch
• Iteration ：for, while, loop
• 递归 Recursion（Divide & Conquer，Backtrace）

之后，算法有下列系列：

• 搜索（Search）：深度优先搜索（Depth first search），广度优先搜索（Breadth first search），A*，…
• 动态规划 Dynamic Programming
• 二分查找 Binary Search
• 贪心 Greedy
• 数学 Math，几何 Geometry