算法知识绪论

申明

  本文章属于原创，其中参考了程杰老师《大话数据结构》行文结构和内容，侵删。

1. 数据结构与算法关系

  数据结构和算法实际上是相辅相成的关系，只谈数据结构的话，其实可以在很短的时间内介绍完，但是我们会不知道这些数据结构到底有何用处。在本专题谈到的算法，是为了更好的理解数据结构，并不会讲到算法的方方面面。

2. 两种算法的比较

  如果让你写一个从1加到100度求和程序，你应该如何实现？下面这段代码可能是大多数人的思路：

int i, sum = 0, n = 100;
for (i = 1; i <= n; ++i)
{
	sum = sum + i;
}
printf("sum result %d", sum);

  然而这样实现是否真的高效呢？其实用高斯公式可以这样实现：

int sum = 0, n = 100;
sum = (1 + 100) * n / 2;
printf("sum result %d", sum);

  可能你在计算机上运行了上面两种程序，发现并没有区别，但是如果将求和的范围扩大到一千、一亿呢？

3. 算法定义

  如今普遍认可的算法定义是：算法是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。

4. 算法的特性

4.1 输入输出

  **算法具有零个或多个输入，至少有一个或者多个输出。**输出的形式可以是打印输出，也可以是返回一个或多个值等。

4.2 有穷性

  有穷性：指算法在执行有限的步骤之后，自动结束而不会出现无限循环，并且每一个步骤在可以接受的时间内完成。

4.3 确定性

  确定性：算法的每一步骤都具有确定的含义，不会出现二义性。

4.4 可行性

  可行性：算法的每一步都必须是可行的，也就是说，每一步都能够通过执行有限次数完成。

5. 算法的设计要求

5.1 正确性

  正确性：算法的正确性是指算法至少应该具有输入、输出和加工处理无歧义性、能正确反映问题的需求、能够得到问题的正确答案。
  但是算法的“正确”通常在用法上有很大的差别，大体分为以下四个层次。
  1. 算法程序没有语法错误。
  2.算法程序对于合法的输入数据能够产生满足要求的输出结果。
  3.算法程序对于非法的输入数据能够得出满足规格说明的结果。
  4.算法程序对于精心选择的，甚至刁难的测试数据都有满足要求的输出结果。
  层次4几乎不能用逐一验证的方法来验证所有的输入都能得到正确的结果，因此算法的正确性大部分情况下都不可能用程序来证明，而是用数学方法来证明。证明一个复杂算法在所有层次上都是正确的，代价非常昂贵。所以一般情况下，我们把层次3作为一个算法是否正确的标准。

5.2 可读性

  可读性：算法设计的另一个目的是为了便于阅读、理解和交流。

5.3 健壮性

  一个好的算法应该能对输入数据不合法的情况做合适的处理。比如输入的时间或者距离不应该是负数等。
  健壮性：当输入数据不合法时，算法也能做出相关处理，而不是产生异常或者莫名其妙的结果。

5.4 时间效率高和存储量低

  时间效率指的是算法的执行时间，对于同一问题，如果有多个算法能够解决，执行时间短的算法效率高，执行时间长的效率低。存储量需求指的是算法在执行过程中需要的最大存储空间，主要指算法程序运行时所占用的内存或者外部硬盘存储空间。设计算法应该尽量满足时间效率高和存储量低的需求。

6. 算法效率的度量方法

6.1 事后统计法

  事后统计法：这种方法主要是通过设计好的测试程序和数据，利用计算机计时器对不同算法编制的程序等运行时间进行比较，从而确定算法效率的高低。
  但是这种方法显然有很大的缺陷：它受计算机软硬件等环境因素的影响，同时测试数据设计困难，并且程序的运行时间还与测试数据的规模有很大的关系，效率高的算法在小的测试数据面前往往得不到体现。
  所以基于时候统计法有这样那样的缺陷，我们考虑不予采纳。

6.2 事前分析估算法

  事前分析估算法：在计算机程序编制前，依据统计方法对算法进行估算。
  一个用高级程序语言编写的程序在计算机上运行时所消耗的时间取决于下列因素：
  1.算法采用的策略、方法。
  2.编译产生的代码质量。
  3.问题的输入规模。
  4.机器执行指令的速度。
  第1条当然是算法好坏的根本，第2条需要由软件来支持，第4条要看硬件性能。也就是说，抛开这些与计算机硬件、软件有关的因素，一个程序的运行时间，依赖于算法的好坏和问题的输入规模。所谓问题的输入规模是指输入量的多少。
  还是来看两种求和算法的例子：
  第一种算法：

int i, sum = 0, n = 100;		/* 执行1次 */
for (i = 1; i <= n; ++i)		/* 执行了n+1次 */
{
	sum = sum + i;				/* 执行n次 */
}
printf("sum result %d", sum);	/* 执行1次 */

  第二种算法：

int sum = 0, n = 100;			/* 执行1次 */
sum = (1 + 100) * n / 2;		/* 执行1次 */
printf("sum result %d", sum);	/* 执行1次 */

  显然，第一种算法执行了1+（n+1）+n+1次=2n+3次；第二种算法执行了1+1+1=3次。事实上两种算法第一条和最后一条语句是一样的，所以我们关注的代码其实是中间那部分，我们把循环看作一个整体，忽略头尾循环的判断开销，那么这两个算法就是n次与1次的差距，好坏显而易见。
  在分析程序的运行时间时，最重要的是把程序看成是独立于程序设计语言的算法或一系列步骤。

7. 函数的逐渐增长

次数	算法A(2n+3)	算法A’(2n)	算法B(3n+1)	算法B’(3n)
n = 1	5	2	4	3
n = 2	7	4	7	6
n = 3	9	6	10	9
n = 10	23	20	31	30
n = 100	203	200	301	300
通过观察表格我们得出这样的定义，输入规模n在没有限制的情况下，只要超过一个数值N，这个函数就总是大于另一个函数，我们称函数是渐近增长的。
函数的渐近增长：给定两个函数f(n)和g(n)，如果存在一个整数N，使得对于所有的n>N,f(n)总是比g(n)大，那么，我们说f(n)的增长渐近快于g(n)。
从中我们发现，随着n的增大，后面的+3还是+1其实是不影响最终的算法变化的，所以我们可以忽略这些加法常数。实际上通过上述表格举一反三，最终判断一个算法的效率时，函数中的常数和其他次要项常常可以忽略，而更应该关注主项(最高阶项)的阶数。
**某个算法，随着n的增大，它会越来越优于另一算法，或者越来越差于另一算法。**这其实就是事前估算法的理论依据，通过算法时间复杂度来估算算法时间效率。

8. 算法时间复杂度

8.1 算法时间复杂度定义

  在进行算法分析时，语句总的执行次数T(n)是关于问题规模n的函数，进而分析T(n)随n的变化情况并确定T(n)的数量级。算法的时间复杂度，也就是算法的时间量度，记作：T(n)=O(f(n))。它表示随问题规模n的增大，算法执行时间的增长率和f(n)的增长率相同，称作算法的渐近时间复杂度，简称为时间复杂度。其中f(n)是问题规模n的某个函数。
  这样用大写O()来体现算法时间复杂度的记法，我们称之为大O记法。
  一般情况下，随着n大增大，T(n)增长最慢的算法称之为最优算法。我们通常把O(1)叫做常数阶、O(n)叫做线性阶、O(n²)叫平方阶。

8.2 推导大O阶方法

  推导大O阶：
  1.用常数1取代运行时间中的所有加法常数。
  2.在修改后的运行次数函数中，只保留最高阶项。
  3.如果最高阶项存在且不是1，则去除与这个项相乘的常数。
  得到的结果就是大O阶。

8.3 常数阶

  如果不存在循环体，那么根据大O阶大推导方法，不管这个常数是多少，我们都记作O(1)，而不能是O(3)，O(12)等其他任何数字，这是初学者常常犯的错误。
  对于分支结构而言，无论是真，还是假，执行的次数都是恒定的，不会随着n的变大而发生变化，所以单纯的分支结构（不包含在循环结构中），其时间复杂度也是O(1)。

8.4 线性阶

  线性阶的循环结构会复杂很多。要确定某个算法的阶次，我们常常需要确定某个特定语句或者语句集运行的次数。因此，我们要分析算法的复杂度，关键就是要分析循环结构的运行情况。
  下面这段代码，它的循环的时间复杂度为O(n)，因为循环体中的代码要执行n次。

int i;
for（i = 0; i < n; i++）
{
	/* 时间复杂度为O(1)的程序步骤序列 */
}

8.5 对数阶

int count = 1;
while count < n）
{
	count = count * 2;
	/* 时间复杂度为O(1)的程序步骤序列 */
}

  由于每次count乘以2之后，就距离n更近了一分。也就是说，有多少个2相乘后大于n，则会退出循环。由2^n 得到x=log_2⁡n(以2为底n的对数)。所以这个循环的时间复杂度为O(logn)。

8.6 平方阶

  下面这个例子是一个嵌套循环，外层循环次数改为了m，时间复杂度为O(m*n)。

int i,j;
for（i = 0; i < m; i++）
{
	for（j = 0; j < n; j++）                
	{                                      
		/* 时间复杂度为O(1)的程序步骤序列 */
	}                                      
}

9. 常见的时间复杂度

  常见时间复杂度如下表：

  注意，经常将log2n（以2为底的对数）简写成logn
  常用的时间复杂度所耗费的时间从小到大依次是：
O(1) < O(logn) < O(n) < O(nlogn) < O(n2) < O(n3) < O(2n) < O(n!) < O(nn)

10. 最坏情况与平均情况

  我们查找一个有n个随机数字数组中的某个数字，最好的情况是第一个数字就是，那么算法的时间复杂度为O(1)，但是也有可能这个数字在最后，那么算法的时间复杂度就是O(n)，这是最坏的一种情况了。
  最坏情况运行时间是一种保证，那就是运行时间将不会再坏了。在应用中，这是一种最重要的需求，通常，除非特别指定，我们提到的运行时间都是最坏情况的运行时间。
  而平均运行时间也就是从概率的角度看，这个数字在每一个位置的可能性是相同的，所以平均的查找时间为n/2次后发现这个目标元素。
  **平均运行时间是所有情况中最有意义的，因为它是期望的运行时间。**可现实中，平均分析时间很难通过分析得到，一般都是通过运行一定数量的实验数据后估算出来的。
  对算法的分析，一种方法是计算所有情况的平均值，这种时间复杂度的计算方法称为平均时间复杂度。另一种方法是计算最坏情况下的时间复杂度，这种方法称为最坏时间复杂度。一般在没有特殊说明的情况下，都是指最坏时间复杂度。

11. 算法空间复杂度

  算法的空间复杂度通过计算算法所需的存储空间实现，算法空间复杂度的计算公式记作：S(n) = O(f(n))，其中，n为问题的规模，f(n)为语句关于n所占存储空间的函数。
  一般情况下，一个程序在机器上执行时，除了需要存储程序本身的指令、常数、变量和输入数据外，还需要存储对数据操作的存储单元。若输入数据所占空间只取决于问题本身，和算法无关，这样只需要分析该算法在实现时所需的辅助单元即可。若算法执行时所需的辅助空间相对于输入数据量而言是个常数，则称此算法为原地工作，空间复杂度为O(1)。
  通常，我们都使用“时间复杂度”来指运行时间的需求，使用“空间复杂度”指空间需求。当不用限定词地使用“复杂度”时，通常都是指时间复杂度。

12. 总结回顾

  算法的定义：算法是解决特定问题求解步骤的描述，在计算机中为指令的有限序列，并且每条指令表示一个或多个操作。
  算法的特性：有穷性、确定性、可行性、输入、输出。
  算法的设计要求：正确性、可读性、健壮性、高效率和低存储量需求。
  算法特性和算法设计容易混，需要对比记忆。
  算法的度量方法：事后统计方法（不科学、不准确）、事前分析估算方法。
  推导大O阶：
  1.用常数1取代运行时间中的所有加法常数。
  2.在修改后的运行次数函数中，只保留最高阶项。
  3.如果最高阶项存在且不是1，则去除与这个项相乘的常数。
  得到的结果就是大O阶。
  常用的时间复杂度所耗费的时间从小到大依次是：
O(1) < O(logn) < O(n) < O(nlogn) < O(n2) < O(n3) < O(2n) < O(n!) < O(nn)

13. 专栏知识链接

1. 数据结构绪论
2. 算法绪论
3. 线性表详解(静态链表、单链表、双向链表、循环链表)
4. 栈与队列详解