算法和算法评价

一、算法

算法是对特定问题求解步骤的一种描述，它是指令的有限序列，其中的每条指令表示一个或多个操作。此外，一个算法具有下列五个重要特性：

（1）有穷性。一个算法必须总在执行有穷步之后结束，且每一步都可在有穷时间内完成。
（2）确定性。算法中每条指令必须有确切的含义，对于相同的输入只能得出相同的输出。
（3）可行性。算法中描述的操作都可以通过已经实现的基本运算执行有限次来实现。
（4）输入。一个算法有零个或多个的输入，这些输入取自于某个特定的对象的集合。
（5）输出。一个算法有一个或多个的输出，这些输出是同输入有着某种特定关系的量。

通常，设计一个“好”的算法应考虑达到以下目标：

（1）正确性。算法应当能够正确地解决求解问题。 （2）可读性。算法应当具有良好的可读性，以助于人们理解。
（3）健壮性。当输入非法数据时，算法也能适当地做出反应或进行处理，而不会产生莫名其妙的输出结果。
（4）效率与低存储量需求。效率是指算法执行的时间，存储量需求是指算法执行过程中所需要的最大存储空间，这两者都与问题的规模有关。

二、算法效率的度量

算法效率的度量是通过时间复杂度和空间复杂度来描述的。

1、时间复杂度

1.1、时间频度

一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，其花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度，记为 T(n)。例如，计算 1-100 所有数字之和，使用for循环计算：时间频度为T(n)=n+1；使用公式计算：时间频度为T(n)=1。

int total=0;
int end=100;
//使用for循环计算：时间频度为T(n)=n+1
for(int i=1;i<=end;i++) {
	total+=i;
}
	
//使用公式计算：时间频度为T(n)=1
total=(1+end)*end/2;

（1）时间频度忽略常数项：

2n+20 和 2n 随着 n 变大， 执行曲线无限接近, 20 可以忽略
3n+10 和 3n 随着 n 变大， 执行曲线无限接近, 10 可以忽略

（2）时间频度忽略低次项：

2n^2+3n+10 和 2n^2 随着 n 变大, 执行曲线无限接近, 可以忽略 3n+10
n^2+5n+20 和 n^2 随着 n 变大,执行曲线无限接近, 可以忽略 5n+20

（3）时间频度忽略系数：

5n^2+7n 和 3n^2 + 2n随着 n 变大， 执行曲线重合, 说明这种情况下, 5和3可以忽略
n^3+5n 和 6n^3+4n随着 n 变大， 执行曲线重合, 说明这种情况下, 1和 6可以忽略

1.2、时间复杂度

一般情况下， 算法中的基本操作语句的重复执行次数是问题规模 n 的某个函数， 用 T(n)表示， 若有某个辅助函数 f(n)， 使得当 n 趋近于无穷大时， T(n) / f(n) 的极限值为不等于零的常数， 则称 f(n)是 T(n)的同数量级函数。记作 T(n)=Ｏ ( f(n) )， 称Ｏ ( f(n) ) 为算法的渐进时间复杂度， 简称时间复杂度。T(n) 不同， 但时间复杂度可能相同。
例如， T(n)=n²+7n+6 与 T(n)=3n²+2n+2 它们的 T(n) 不同， 但时间复杂度相同， 都为 O(n²)。

计算时间复杂度的方法：

（1）用常数1代替运行时间中的所有加法常数
T(n)=n²+7n+6 => T(n)=n²+7n+1
（2） 修改后的运行次数函数中，只保留最高阶项
T(n)=n²+7n+1 => T(n) = n²
（3）去除最高阶项的系数
T(n) = n² => T(n) = n² => O(n²)

1.3、常见的时间复杂度

常数阶 O(1)
对数阶 O(log2n)
线性阶 O(n)
线性对数阶 O(nlog2n)
平方阶 O(n^2)
立方阶 O(n^3)
k 次方阶 O(n^k)
指数阶 O(2^n)

常见的算法时间复杂度由小到大依次为： Ο (1)＜Ο (log2n)＜Ο (n)＜Ο (nlog2n)＜Ο (n^2)＜Ο (n^3)＜ Ο (n^k) ＜ Ο (2^n)（＜ Ο (n!) ＜ Ο (n^n)） ， 随着问题规模 n 的不断增大， 上述时间复杂度不断增大， 算法的执行效率越低。

从下图中可见， 我们应该尽可能避免使用指数阶的算法。

1.3.1、常数阶 O(1)

无论代码执行了多少行，只要是没有循环等复杂结构，则这个代码的时间复杂度都是O(1)。

代码在执行的时候，它消耗的时候并不随着某个变量的增长而增长，那么无论这类代码有多长，即使有几万几十万行，都可以用O(1)来表示它的时间复杂度。

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

1.3.2、对数阶 O(log2n)

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

对于上述代码，在while循环里，每次将 i 乘以2，即 i 的值为2,4,8，16…… 假设循环x次，即有2^x=n，则x=log2n，即该代码的时间复杂度为O(log2n)。若 i=i * 3，则时间复杂度为O(log3n)；若 i=i*4，则时间复杂度为O(log4n)等等。

1.3.3、线性阶 O(n)

for(int i=1;i<=n;i++){
    i+=1;
 }

for循环里面的代码会执行n遍，这类代码都可以用O(n)来表示其时间复杂度。

1.3.4、线性对数阶 O(nlog2n)

int j = 1;
int n = 100;
		
for (int i = 1; i <= n; i++) {
	while (j < n) {
		j = j * 2;
	}
}

将时间复杂度为O(log2n)的代码循环n遍，其时间复杂度即为 n * O(log2n)，即O(nlog2n)。

1.3.5、平方阶 O(n²)

int n=100;
for(int i=1;i<=n;i++) {
	for(int j=1;j<=n;j++) {
		int m=i*j;
	}
}

将时间复杂度为O(n) 的代码再嵌套循环一遍，其时间复杂度是 O(n²)；若将其中一层循环的n改成m，其时间复杂度就变为O(m*n)。

1.3.6、立方阶 O(n³)

int n=100;
for(int i=1;i<=n;i++) {
	for(int j=1;j<=n;j++) {
		for(int k=1;k<=n;k++) {
			int m=i*j*k;
		}	
	}
}

将时间复杂度为O(n) 的代码再嵌套循环两遍，其时间复杂度是 O(n³)。

1.3.7、其他阶

k 次方阶 O(n^k) 和指数阶 O(2^n)类似上面理解。

1.4、平均时间复杂度和最坏时间复杂度

平均时间复杂度是指所有可能的输入实例均以等概率出现的情况下， 该算法的运行时间。

最坏情况下的时间复杂度称最坏时间复杂度。 一般讨论的时间复杂度均是最坏情况下的时间复杂度。 这样做的原因是： 最坏情况下的时间复杂度是算法在任何输入实例上运行时间的界限， 这就保证了算法的运行时间不会比最坏情况更长。

2、空间复杂度

算法的空间复杂度 S(n）定义为该算法所耗费的存储空间，它是问题规模n的函数，记为：S(n)=O(g(n))。一个程序在执行时除需要存储空间来存放本身所用的指令、常数、变量和输入数据外，还需要一些对数据进行操作的工作单元和存储一些为实现计算所需信息的辅助空间。若输入数据所占空间只取决于问题本身，和算法无关，则只需分析除输入和程序之外的额外空间。算法原地工作是指算法所需的辅助空间为常量，即O(1)。