数据结构-算法和算法分析

目录

• 前言
• 一、算法
• • [1.1 算法与程序](#1.1 算法与程序)
  • [1.2 算法描述方法](#1.2 算法描述方法)
  • [1.3 算法特性](#1.3 算法特性)
  • [1.4 算法设计的要求](#1.4 算法设计的要求)
• 二、算法分析
• • [2.1 算法时间效率的度量](#2.1 算法时间效率的度量)
  • • [2.1.1 事前分析方法](#2.1.1 事前分析方法)
    • • 算法的渐进时间复杂度
      • 算法时间复杂度分析例子
      • 算法最坏时间复杂度
      • 时间复杂度的计算规则
  • [2.2 算法空间效率的度量](#2.2 算法空间效率的度量)
• 总结

前言

程序 = 数据结构+算法
数据结构通过算法实现操作
算法根据数据结构设计程序

一、算法

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

简而言之，算法就是解决问题的方法和步骤。

1.1 算法与程序

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

1.2 算法描述方法

• 自然语言：中文、英语等
• 流程图：传统流程图、NS流程图（盒图）等
• 伪代码：类C语言（类语言）等
• 程序代码：C语言程序、JAVA语言程序等

1.3 算法特性

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

1.4 算法设计的要求

• 正确性（Correctness）
  如果一个算法以一组满足初始条件的输入开始，那么该算法的执行一定会终止，并且在终止时得到满足要求的输出
• 可读性（Readability）
  一个算法的描述应该是便于人的阅读，以便于人对算法的理解
• 健壮性（Robustness）
  算法的健壮性也叫鲁棒性，指当输入不合法的数据时，算法恰当地作出反应。
  处理出错的方法，不应是中断程序的执行，而是应该返回一个表示错误或错误性质的值，以便在更高的抽象层次上进行处理。
• 高效性（Efficiency）
  要求花费尽量少的运行时间和存储空间

二、算法分析

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

算法效率包含时间效率 和空间效率
时间效率：指的是算法执行完成后所耗费的时间
空间效率：指的是算法执行过程中所耗费的存储空间

有时候，算法的时间效率和空间效率两者之间会出现矛盾，不能既要时间效率，又要空间效率。所以，有些情况需要用时间效率换空间效率，还有些情况需要用空间效率换时间效率。

下面，分别介绍如何分析一个算法的时间效率和空间效率

2.1 算法时间效率的度量

度量算法的时间效率的方法包含以下两种：

• 事后统计
  事后统计是指将算法使用程序设计语言实现后运行，统计其时间和空间的开销
• 事前分析
  事前分析是指对算法所消耗的资源按照某种方法进行估算

由于事后统计这个度量方法需要编写程序实现算法，所得统计结果依赖于计算机的软硬件等环境因素，掩盖算法本身的优劣。所以，采用事前分析这个度量方法进行算法时间效率的分析。

2.1.1 事前分析方法

一个算法的运行时间是指一个算法在计算机上运行所耗费的时间大致可以等于计算机执行一种简单操作所需的时间与算法中进行简单操作次数的乘积
算法运行时间 = ∑每条语句的执行次数×该语句执行一次所需的时间

语句的执行次数又称为语句频度
每条语句执行一次所需时间，一般随机器而异。取决于机器的指令性能、速度以及编译的代码质量。是由机器本身软硬件环境决定的，与算法无关。
所以，假设执行每条语句所需的时间均为单位时间。那么对算法的运行时间的讨论就可以转化为讨论该算法中所有语句的执行次数，即频度之和。通过这样，就可忽略机器的软硬件环境。

根据以上，可得出算法运行时间 = ∑每条语句的频度

例子，两个n×n矩阵相乘的算法可描述为（类C语言描述）:

for(i = 1; i <= n; i++)  								//n+1次
	for(j = 1; j <= n; j++){							//n*(n+1)次
		c[i][j] = 0;									//n*n次
		for(k = 0; k < n; k++)							//n*n*(n+1)次
			c[i][j] = c[i][j] + a[i][k] * b[k][i];		//n*n*n次
	}		

算法所耗费的时间定义为该算法每条语句频度之和，则上述算法的时间消耗为:
T ( n ) = n + 1 + n ∗ ( n + 1 ) + n ∗ n + n ∗ n ∗ ( n + 1 ) + n ∗ n ∗ n T(n) = n+1+n * (n+1)+n * n+n * n * (n+1)+n * n * n T(n)=n+1+n∗(n+1)+n∗n+n∗n∗(n+1)+n∗n∗n

整理得 T ( n ) = 2 n 3 + 3 n 2 + 2 n + 1 T(n) = 2n^3 +3n^2+2n+1 T(n)=2n3+3n2+2n+1

为了便于比较不同算法的时间效率，这里仅仅比较不同算法的数量级，即算法的渐进时间复杂度

算法的渐进时间复杂度

若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数 ，即
T ( n ) = O ( f ( n ) ) T(n)=O(f(n)) T(n)=O(f(n))
称 O ( f ( n ) ) O(f(n)) O(f(n))为算法的渐进时间复杂度（ O O O是数量级的符号） ，简称时间复杂度。

那么，根据算法的渐进时间复杂度的定义，对于求解矩阵相乘问题，算法耗费时间：
T ( n ) = 2 n 3 + 3 n 2 + 2 n + 1 T(n)=2n^3+3n^2+2n+1 T(n)=2n3+3n2+2n+1
n → ∞ {n \to \infty} n→∞时， T ( n ) / n 3 → 2 {T(n)/n^3 \to 2} T(n)/n3→2，那么， T ( n ) 和 n 3 T(n)和n^3 T(n)和n3是同阶或同数量级，引入大 O O O记号，则 T ( n ) T(n) T(n)可记作:
T ( n ) = O ( n 3 ) T(n)=O(n^3) T(n)=O(n3)

即 O ( n 3 ) O(n^3) O(n3)就是求解矩阵相乘问题的算法的渐进时间复杂度。

一般情况下，不必计算所有操作的执行次数，而只考虑算法中基本操作 执行的次数，它是问题规模n的某个函数，用f(n)表示

算法中基本语句重复执行的次数 是问题规模n 的某个函数f(n)，算法的时间度量记作: T ( n ) = O ( f ( n ) ) T(n)=O(f(n)) T(n)=O(f(n))
基本语句：执行次数最多

问题规模n在不同的问题中，表示的意义不同

排序问题：问题规模n表示记录数

矩阵问题：问题规模n表示矩阵的阶数

多项式问题：问题规模n表示多项式的项数

集合问题：问题规模n表示元素的个数

树问题：问题规模n表示树的结点个数

图问题：问题规模n表示图的顶点数或边数

算法时间复杂度分析例子

定理1.1
若 f ( n ) = a m n m + a m − 1 n m − 1 + . . . + a 1 n + a 0 f(n)={a_m}{n^m}+a_{m-1}{n^{m-1}}+...+{a_1}{n}+{a_0} f(n)=amnm+am−1nm−1+...+a1n+a0是m次多项式， T ( n ) = O ( n m ) T(n)=O(n^m) T(n)=O(nm)

忽略所有低次幂项和最高次幂系数

分析算法时间复杂度的基本步骤 ：
step1：找出语句频度最大的那条语句作为基本语句
step2：计算基本语句的频度得到问题规模n的某个函数 f ( n ) f(n) f(n)
step3：取 f ( n ) f(n) f(n)数量级用符号 O O O表示

例子1

for(i = 1; i <= n; i++)
	for(j = 1; j <= i; j++)
		for(k = 1; k <= j; k++)
			x = x + 1;

把 x = x + 1 x=x+1 x=x+1作为基本语句，则其 f ( n ) f(n) f(n)
f ( n ) = ∑ i = 1 n ∑ j = 1 i ∑ k = 1 j 1 = ∑ i = 1 n ∑ j = 1 i j = ∑ i = 1 n i ( i + 1 ) 2 = 1 2 ( ∑ i = 1 n i 2 + ∑ i = 1 n i ) = 1 2 ( n ( n + 1 ) ( 2 n + 1 ) 6 + n ( n + 1 ) 2 ) = n ( n + 1 ) ( n + 2 ) 6 \begin{aligned} f(n) ={\overset{n}{\underset{i=1}{\sum}}}{\overset{i}{\underset{j=1}{\sum}}}{\overset{j}{\underset{k=1}{\sum}}}1 ={\overset{n}{\underset{i=1}{\sum}}}{\overset{i}{\underset{j=1}{\sum}}}j &={\overset{n}{\underset{i=1}{\sum}}} \frac{i(i+1)}{2}\\ &=\frac{1}{2} ({\overset{n}{\underset{i=1}{\sum}}}i^2+{\overset{n}{\underset{i=1}{\sum}}}i)\\ &=\frac{1}{2}(\frac{n(n+1)(2n+1)}{6}+\frac{n(n+1)}{2})\\ &=\frac{n(n+1)(n+2)}{6} \end{aligned} f(n)=i=1∑nj=1∑ik=1∑j1=i=1∑nj=1∑ij=i=1∑n2i(i+1)=21(i=1∑ni2+i=1∑ni)=21(6n(n+1)(2n+1)+2n(n+1))=6n(n+1)(n+2)

综上， T ( n ) = O ( n 3 ) T(n)=O(n^3) T(n)=O(n3)

例子2

i = 1;
while(i <= n)
	i = i*2;

把 i = i ∗ 2 i=i*2 i=i∗2作为基本语句，则 f ( n ) f(n) f(n)

若循环执行1次： i = 1 ∗ 2 = 2 i=1*2=2 i=1∗2=2，

若循环执行2次： i = 2 ∗ 2 = 2 2 i=2*2=2^2 i=2∗2=22，

若循环执行3次： i = 3 ∗ 2 = 2 3 i=3*2=2^3 i=3∗2=23，...，

若循环执行x次： i = 2 x i=2^x i=2x，

设基本语句执行x次，由循环条件 i < = n i<=n i<=n， ∴ 2 x < = n ∴ x < = log ⁡ 2 n \therefore2^x<=n \therefore x<=\log_2n ∴2x<=n∴x<=log2n

即 2 f ( n ) < = n , 即 f ( n ) < = log ⁡ 2 n ，取最大值 f ( n ) = log ⁡ 2 n 2^{f(n)}<=n,即f(n)<=\log_2n，取最大值f(n)=\log_2n 2f(n)<=n,即f(n)<=log2n，取最大值f(n)=log2n

综上， T ( n ) = O ( log ⁡ 2 n ) T(n)=O(\log_2n) T(n)=O(log2n)

算法最坏时间复杂度

有的情况下，算法中基本操作重复执行的次数还随着输入数据集不同而不同。

例如，在一个数组中顺序查找一个数e，返回其位置

for(i = 0; i < n; i++)
	if(e == a[i])
		return i;
 return -1;		

最好情况：循环遍历1次

最坏情况：循环遍历n次

平均时间复杂度: O ( n ) O(n) O(n)

最好时间复杂度：指在最好情况下，算法的时间复杂度
最坏时间复杂度：指在最坏情况下，算法的时间复杂度
平均时间复杂度：指在所有可能输入实例在等概率出现的情况下，算法的期望运行时间
一般情况下，总是考虑最坏情况下的时间复杂度，以保证算法的运行时间不会比它更长。

时间复杂度的计算规则

对于复杂的算法，可以将它分成几个容易估算的部分，然后利用大 O O O加法规则和乘法规则，计算算法的时间复杂度

• 加法规则
  T ( n ) = T 1 ( n ) + T 2 ( n ) = O ( f 1 ( n ) ) + O ( f 2 ( n ) ) = O ( m a x ( f 1 ( n ) , f 2 ( n ) ) ) T(n)=T_1(n)+T_2(n)=O(f_1(n))+O(f_2(n))=O(max(f_1(n),f_2(n))) T(n)=T1(n)+T2(n)=O(f1(n))+O(f2(n))=O(max(f1(n),f2(n)))
  这里的 m a x ( f 1 ( n ) , f 2 ( n ) ) 表示当 n → ∞ 时，取函数值较大的那个函数 max(f_1(n),f_2(n))表示当n \to \infty时，取函数值较大的那个函数 max(f1(n),f2(n))表示当n→∞时，取函数值较大的那个函数
  常见的函数大小关系如下：
  O ( 1 ) < O ( l o g 2 n ) < O ( n ) < O ( n l o g 2 n ) < O ( n 2 ) < O ( n 3 ) < O ( 2 n ) O(1)<O(log_2n)<O(n)<O(nlog_2n)<O(n^2)<O(n^3)<O(2^n) O(1)<O(log2n)<O(n)<O(nlog2n)<O(n2)<O(n3)<O(2n)
• 乘法规则
  T ( n ) = T 1 ( n ) × T 2 ( n ) = O ( f 1 ( n ) ) × O ( f 2 ( n ) ) = O ( f 1 ( n ) × f 2 ( n ) ) T(n)=T_1(n)\times T_2(n)=O(f_1(n))\times O(f_2(n))=O(f_1(n)\times f_2(n)) T(n)=T1(n)×T2(n)=O(f1(n))×O(f2(n))=O(f1(n)×f2(n))

2.2 算法空间效率的度量

算法空间效率的度量使用渐进空间复杂度进行分析

空间复杂度：算法所需存储空间的度量，记作 S ( n ) = O ( f ( n ) ) S(n)=O(f(n)) S(n)=O(f(n))

其中，n为问题规模

算法要占据的空间：

1. 算法本身要占据的空间，输入/输出，指令，常数，变量等
2. 算法要使用的辅助空间

例子

将一个一维数组a中的n个数逆序存放到原数组中

算法1

//利用辅助空间变量t
for(i = 0; i < n/2; i++)
{
	t = a[i];
	a[i] = a[n-i-1];
	a[n-i-1] = t
}

空间复杂度 S ( n ) = O ( 1 ) S(n)=O(1) S(n)=O(1)

算法2

//利用辅助空间数组b[]
for(i = 0; i < n; i++)
	b[i] = a[n-i-1];
for(i = 0; i < n; i++)
	a[i] = b[i]	

空间复杂度 S ( n ) = O ( n ) S(n)=O(n) S(n)=O(n)

总结