数据结构——算法（二）

数据结构——算法（二）

作者：黑衣侠客

---

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

一、算法的定义

算法是什么呢？

算法是描述解决问题的方法，算法这个单词最早出现在波斯数学家阿勒·花剌子密在公元825年（相当于我们中国唐朝时期）所写的《印度数字算数》中。

那么现如今，公众普遍认为的定义为：

算法是解决特定问题求解的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。
世界上，现实中的问题千奇百怪，算法也当然就千变万化，从来没有通用的算法可以解决所有的问题。甚至解决一个小问题，特别厉害的算法都不一定适合它。==算法定义中，提到了指令，指令能被人或机器等计算装置执行。它可以是计算机指令，也可以是我们平时的语言文字。==为了解决某个或某类问题，需要把指令表示成一定的操作序列，操作序列包括一组操作，每一个操作都完成特定的功能，这就是算法了。

二、算法的特性

算法具有：输入、输出、有穷性、确定性和可行性五个特点。

1.输入输出

算法的输入可以是零个，因此，我们说算法具有零个或多个输入。
但是算法至少要有一个或多个输出，算法是一定需要输出的，不需要输出，那么，我们运用的算法就没有任何含义了，输出的形式可以是打印输出，也可以是返回一个或多个值等。

2. 有穷性

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

3. 确定性

确定性：算法的每一步骤都具有确定的含义，不会出现二义性。
算法在一定条件下，只有一条执行路径，相同的输入只能有唯一的输出结果。算法的每个步骤被精确定义而无歧义。

4. 可行性

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

可行性意味着算法可以转换为程序上级运行，并得到正确的结果。尽管在目前计算机界也存在那种没有实现的极为复杂的算法，不是说理论上不能实现，而是因为过于复杂，我们当前的编程方法、工具和大脑限制了这个工作，不过这都是理论研究领域的问题，不属于我们现在要考虑的范围。

5.算法的设计和要求

① 正确性

正确性：算法的正确性是指算法至少应该具有输入、输出和加工处理无歧义性、能够正确反映问题的需求、狗得到问题的正确答案。

包括：

1. 算法程序没有语法错误
2. 算法程序对于合法的输入数据能够产生满足要求的输出结果
3. 算法程序对于非法的输入数据能够得出满足规格说明的结果
4. 算法程序对于精心选择的，甚至刁难的测试数据都有满足要求的输出结果

② 可读性

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

可读性高有助于人们理解算法，晦涩难懂的算法往往隐含错误，不易被发现，并且难以调试和修改，而我们写代码的目的，一方面是为了让计算机执行，但还有一个重要的目的是为了便于他人阅读，让别人更好的理解和交流，如果可读性不好，时间长了自己都不知道写了什么，因此，可见可读性是算法好坏的重要标志。

③ 健壮性

健壮性：当输入数据不合法时，算法也能做出相关的处理，而不是产生异常或莫名其妙的结果。

④ 时间效率高和存储量低

好的算法还应该具有时间效率高和存储量低的特点

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

好的算法应该同时具备：正确性、可读性、健壮性、高效率和低存储量的特点

三、算法效率的度量方法

设计算法想要提高效率，必须提高算法的执行时间，那么我们该如何提高算法的执行时间呢？

1. 事后统计法

事后统计法：这种方法主要是通过设计好的测试程序和数据，利用计算机计时器对不同算法编制的程序的运行时间进行比较，从而确定算法效率的高低。

但是这种算法显然还是有很多缺陷的：

1. 必须依据算法事先编制好程序，这通常需要花费大量的时间和精力。
2. 时间的比较依赖计算机硬件和软件等环境因素，有时会掩盖算法本身的优劣。我们要知道，现在的一台四核处理器的计算机，跟当年286、386、486等计算机相比，在处理算法的运算速度上，是根本不能相提并论的；而所用的操作系统、编译器、运行框架等软件的不同，同时可以影响它们的结果；就算是同一台机器，CPU使用率和内存占用情况不一样，也会造成细微的差异。
3. 算法的测试数据设计困难，并且程序的运行时间往往还与测试数据的规模有很大的关系，效率高的算法在小的测试数据面前往往得不到体现。
   比如：10个数字的排序，不管用什么算法，差异几乎是零。而如果有一百万个随机数字排序，那不同算法的差异就非常大了。因此，我们为了比较算法到底用多少数据来测试，这是一个很难判断的问题。

基于事后统计方法有这样那样的缺陷，因此我们考虑不予采纳。

2. 事前分析估算方法

事前分析估算方法：在计算机程序编程前，依据统计方法对算法进行估算。

我们发现，一个用高级程序语言编写的程序在计算机上运行的时间取决于下列因素：

1. 算法采用的策略、方法（算法好坏的根本）
2. 编译产生的代码质量（软件支持）
3. 问题的输入规模
4. 机器执行指令的速度（硬件性能）

抛开这些来说，一个程序的运行时间，依赖于算法的好坏和问题的输入规模。（问题的输入规模就是指输入量的多少）

四、函数的渐进增长

首先，我们来看一个例子：

假设，两个算法的输入规模都是n，算法A要做2n+3次操作，我们可以理解为现有一个n次的循环，执行完成后，再有一个n次循环，最后有三次赋值或运算，共有2n+3次操作。算法B要做3n+1次操作。那么两个算法相比，哪个算法更快呢？

其实，答案是不一定的

次数	算法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=1时，算法A效率不如算法B（次数比算法B要多一次）。而当n=2时，两者效率相同；当n>2时，算法A就开始优于算法B了，随着n的增加，算法A比算法B越来越好了（执行的次数比B要少）。于是我们可以得出结论，算法A总体上要好过算法B。

此时，我们给出这样的定义：输入规模n在没有限制的情况下，只要超过一个数值N，这个函数就总是大于另一个函数，我们称函数是渐进增长的。
函数的渐进增长：给定两个函数f(n)和g(n),如果存在一个整数N，使得对于所有的n>N , f(n) 总是比 g(n) 大，那么，我们说 f(n) 的增长渐进快于 g(n) 。

从中我们发现，随着n的增大，后面的+3还是+1其实是不影响最终的算法变化的，例如：算法A’与算法B’，所以，我们可以忽略这些加法常数。

判断一个算法的效率时，函数中的常数和其他次要项常常可以忽略，而更应该关注主项（最高阶项）的阶数。

我们常常通过算法的时间复杂度来估算算法的时间效率

五、算法的时间复杂度

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(n), O(1), O(n²)。
我们给它们取了一些费官方的名称：O(1)叫常数阶、O(n)叫线性阶、O(n²)叫平方阶，还有其他的一些阶，等等。

2. 推导大O阶方法

推导大O阶：

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

3. 常数阶

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

该算法的运行次数函数是f(n) =3。根据我们推导大O阶的方法，第一步就是把常数项3改为1.在保留最高阶项时发现，它根本没有最高阶项，所以，这个算法的时间复杂度为O(1)。

不管这个常数是多少，我们都记作O(1)，而不能是O(3)、O(12)等其他任何数字

对于分支结构而言，无论是真，还是假，执行的次数都是恒定的，不会随着n的变化而发生变化，因此，单纯的分支结构（不包含在循环结构中），其时间复杂度也是O(1)。

4. 线性阶

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

这段代码的时间复杂度是O(n)。

5. 对数阶

int count = 1;
while(count < n)
{
	count = count * 2;
}

由于每次count乘以2之后，就距离n更近一分。也就是说，有多少个2相乘后大于n，则将退出循环。由2^x=n得到x=log2ⁿ。所以这个程序的时间复杂度是O(logn)。

6. 平方阶

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

这段代码的时间复杂度是O(n²)。
如果外层循环的次数为m，则时间复杂度就变成了O(m×n)。

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

当然，也有特殊类型

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

此时的算法，应该这么算：

由于当i=0时，内循环执行了n次，当i=1时，执行了n-1次，…当i=n-1时，执行了1次。所以总的执行次数为：
n+(n-1)+(n-2)+…+1=n(n+1)/2=n²/2+n/2

用我们推导大O阶的方法，第一条，没有加法常数不予考虑；第二条，只保留最高阶项，因此，保留n²/2；第三条，去除这个项相乘的常数，也就是去除1/2，最终这段代码的时间复杂度为O(n²)。
我们再来看看下面几个例子：

int i,j;
for(i=0;i<n;i++)
{
	function(i);
}

函数function：

void function(int count)
{
	print(count);
}

其时间复杂度是：O(n)。
但是，如果function函数是下面这种形式：

void function(int count)
{
	int j;
	for(j=count;j<n;j++)
	{
		/*时间复杂度为O(1)的程序步骤序列*/
	}
}

n+(n-1)+(n-2)+(n-3)+…+1=n(n+1)/2=n²/2+n/2
因此，时间复杂度为：O(n²)

再例如：

n++		//执行次数为1
function(n);	//执行次数为n
int i,j;
for(i=0;i<n;i++)	//执行次数为n²
{
	function(i);
}
for(i=0;i<n;i++)	//执行次数是n(n+1)/2
{
	for(j=i;j<n;j++)
	{
		/*时间复杂度为O(1)的程序步骤序列*/
	}
}

执行次数：f(n)=1+n+n²+n(n+1)/2=3/2n²+3/2n+1，根据推导大O阶的方法，最终的代码的时间复杂度为O(n²)。

六、常见的时间复杂度

执行次数函数	阶	非正式术语
12	O(1)	常数阶
2n+3	O(n)	线性阶
3n²+2n+1	O(n²)	平方阶
5log2n+20	O(logn)	对数阶
2n+3nlog2n+19	O(nlogn)	nlogn阶
6n3+2n2+3n+4	O(n3)	立方阶
2n	O(2n)	指数阶

O(1)<O(logⁿ)<O(n)<O(nlogⁿ)<O(n²)<O(2ⁿ)<O(n!)<O(nⁿ)

七、算法的空间复杂度

算法的空间复杂度通过计算算法所需的存储空间来实现，算法空间复杂度的计算公式记作：S(n) ) = O(f(n))，其中，n为问题的规模，f(n)为语句关于n所占存储空间的函数。

一般情况下，一个程序在机器上执行时，除了需要存储程序本身的指令、常数、变量和输入数据外，还需要存储对数据操作的存储单元。若输入数据所占空间只取决于问题本身，和算法无关，这样只需要分析该算法在实现时所需的辅助单元即可。若算法执行时所需的辅助空间相对于输入数据量而言是个常数，则称此算法为原地工作，空间复杂度为O(1)。

通常来说，我们都使用“时间复杂度”来运行时间的需求，使用“空间复杂度”指空间需求。当不用限定词地使用“复杂度”时，通常都是指时间复杂度。显然，我们这里主要还是来说“时间复杂度”。