0x01算法设计与分析复习（一）：算法和算法分析

参考书籍：算法设计与分析——C++语言描述（第二版）

算法问题求解基础

1. 算法概述

算法（algorithm）是求解一类问题的任意一种特殊的方法。教严格的说法是，一个算法是对特定问题求解步骤的一种描述，它是指令的有限序列。
算法具有下面五个特征：

  • 输入（input）：算法有零个或多个输入量
  • 输出（output）：算法至少产生一个输出量
  • 确定性（definiteness）：算法的每一条指令都有确切的定义，没有二义性
  • 能行性（effectiveness）：算法的每一条指令必须足够基本，他们可以通过已经实现的基本运算执行有限次来实现
  • 有穷性（finiteness）：算法必须总能在执行有限步之后终止

概括地说，算法是由一系列明确定义的基本指令序列所描述的，求解特定问题的过程。它能够对合法的输入，在有限时间内产生所要求的输出。
如果取消有穷性限制，则只能称为计算过程（computational procedure）

欧几里德算法

  • 欧几里德算法又称辗转相除法，用于计算两个整数\(m\)和\(n\)（\(0\leq m < n的最大公约数，记为gcd(m,n)\)）。其计算过程是重复应用下列等式，直到\(n \mod m = 0\)。\(gcd(m,n) = gcd(n \mod m, m), 对于m>0\)，式中，\(n \mod m\)表示\(n\)除以\(m\)之后的余数。
#include <stdio.h>

int gcd(int m, int n)
{
	//欧几里得辗转相除法
	//假定m<n
	if(m == 0) {
		return n;
	} else {
		int tmp;
		while(m>0) {
			tmp = n%m;
			n = m;
			m = tmp;
		}
		return n;
	}
}

int Rgcd(int m, int n)
{
	//递归形式
	if(m == 0) {
		return n;
	} else {
		return Rgcd(n%m, ma);
	}
}

int main()
{
	int m, n, r1, r2;
	scanf("%d%d", &m, &n);
	
	if(n>m) {
		r1 = gcd(m,n);
		r2 = Rgcd(m,n);
	} else {
		r1 = gcd(n,m);
		r2 = Rgcd(n,m);
	}
	
	printf("GCD of m and n: %d\n", r1);
	printf("GCD of m and n: %d\n", r2);
	
	
	return 0;
}

一个好的算法应具有以下4个特性

  • 正确性（correctness）：算法的执行结果应当满足预先规定的功能和性能要求
  • 简明性（simplicity）：算法应思路清晰、层次分明、容易理解、利于编码和调试
  • 效率（efficiency）：算法应有效使用存储空间，并具有高的时间效率
  • 最优性（optimality）：算法的执行时间已达到求解该问题所需时间的下限

2. 算法设计与分析

算法一般分两类：精确算法和启发式算法。一个精确算法（exact algorithm）总能保证求得问题的解。而一个启发式算法（heuristic algorithm）通过使用某种规则、简化或智能猜测来减少问题的求解时间。
算法问题求解过程：
算法问题求解过程

3. 递归和归纳

递归（recursive）定义是一种直接或间接引用自身的定义方法。一个合法的递归定义包括两个部分：基础情况（base case）和递归部分。
当一个算法采用递归方式定义时便成为递归算法，一个递归算法是指直接或间接调用自身的算法。递归本质上也是一种循环的算法结构，它把较复杂的计算逐次归结为较简单情形的计算，直至归结到最简单情形的计算，并最终得到计算结果为止。

递归数据结构：使用递归方式定义的数据结构称为递归数据结构（recursive data structure）。

使用归纳法进行证明的过程由两部分组成：
（1）基础情况（base case）确认被证明的结论在某种\某些基础情况下是正确的
（2）归纳步骤（induction step）这一步又可分成两子步：首先进行归纳假设，假定当问题实例的规模小于某个量k时，结论成立；然后使用这个假设证明对问题规模为k的实例，结论成立。至此结论得证。

练习

  1. 逆序输出正整数的各位数（递归算法求解）
  2. 汉诺塔问题
  3. 排序产生算法
  4. 给出\(n!\)的递归定义式，并设计一个递归函数计算\(n!\)
  5. 写一个递归算法和一个迭代算法计算二项式系数：

\[C_n^m = C_{n-1}^m + C_{n-1}^{m-1} = \frac{n!}{m!(n-m)!} \]

  1. 给定一个字符串s和一个字符x，编写递归算法实现下列功能：
    （1）检查x是否在s中
    （2）计算x在s中出现的次数
    （3）删除s中所有的x
  2. 写一个C++函数求解：给定正整数n，确定n是否是它所有因子之和
  3. S是有n个元素的集合，S的幂集是S所有可能的子集组成的集合。例如，\(S = {a, b, c}, 则S的幂集={(),(a),(b),(c),(a,b),(a,c),(b,c),(a,b,c)}\)。写一个C++递归函数，以S为输入，输出S的幂集。

算法分析基础

1. 算法复杂度

一个好的算法应具有一下4个重要特性

  • 正确性（correctness）：算法的执行结果应当满足预先规定的功能和测试要求
  • 简明性（simplicity）：算法应思路清晰、层次分明、容易理解、利于编码和调试
  • 效率（efficiency）：算法应有效使用存储空间，并具有高的时间效率
  • 最优性（optimality）：算法的执行时间已达到求解该类问题所需的时间下界

程序健壮性（robustness)：是指当输入不合法数据时，程序应能做适当处理而不至于引起严重后果。其含义是：当程序万一遇到意外时，能按某种预定方式做出适当处理。正确性和健壮性是相互补充的。

影响程序运行时间的因素主要有

  • 程序所依赖的算法：算法自身的好坏对运行时间的影响是根本的和起决定作用的
  • 问题规模和输入数据：输入数据规模、输出数据规模、数据的数值大小和输入数据的状态
  • 计算机系统性能：计算机硬件系统性能（如CPU速度）、计算机软件系统性能（如操作系统、编译器）

算法的时间复杂度：一个算法的时间复杂度（time complexity）是指算法运行所需的时间。
算法的空间复杂度：一个算法的空间复杂度（space complexity）是指算法运行所需的存储空间。程序运行所需要的存储空间包括以下两部分：（1）固定空间需求（fixed space requirement），（2）可变空间需求（variable space requirement）。

2. 渐进表示法

  1. 大\(O\)记号（渐近上界记号）

    设函数\(f(n)\)和\(g(n)\)是定义在非负整数集合上的正函数，如果存在两个正常数\(c\)和\(n_0\)，使得当\(n\geq n_0\)时，有\(f(n)\leq cg(n)\)，则记作\(f(n)=O(g(n))\)，称为大O记号（big Oh notation）。意义：该算法的运行时间不会超过g(n)的某个常数倍。

  2. \(\Omega\)记号（渐近下界记号）

    设函数\(f(n)\)和\(g(n)\)是定义在非负整数集合上的正函数，如果存在两个正常数\(c\)和\(n_0\)，使得当\(n\geq n_0\)时，有\(f(n)\geq cg(n)\)，则记作\(f(n)=\Omega(g(n))\)，称为\(\Omega\)记号（omega notation）。意义：该算法至少需要g(n)的某个常数倍大小的时间量。

  3. \(\Theta\)记号（紧渐近界记号）

    设函数\(f(n)\)和\(g(n)\)是定义在非负整数集合上的正函数，如果存在两个正常数\(c_1\)、\(c_2\)和\(n_0\)，使得当\(n\geq n_0\)时，有\(c_1g(n)\leq f(n) \leq c_2g(n)\)，则记作\(f(n)=\Theta(g(n))\)，称为\(\Theta\) 记号（Theta notation）。意义：该算法实际运行时间大约为g(n)的某个常数倍大小的时间量。

  4. 小o记号（非紧上界记号）

    \(f(n)=o(g(n))\)当且仅的\(f(n)=O(g(n))\)且\(f(n)\neq \Omega(g(n))\)。意义：该算法的运行时间f(n)的阶比g(n)低。

  5. \(\omega\)记号（非紧下界记号）

    如果对于任何正常数\(c>0\)都存在正整数\(n_0>0\)，使得当\(n\geq n_0\)时有\(f(n)>cg(n)\)（等价于\(n\rightarrow \infty\)t时，\(f(n)/g(n)\rightarrow \infty\)），则称函数\(f(n)\)当\(n\)充分大时的阶比\(g(n)\)高，记做\(f(n)＝\omega(g(n))\)。

算法按时间复杂度分类

算法按计算时间分为两类：凡渐进时间复杂度为多项式时间限界的算法称为多项式时间算法（polynomial time algorithm），而渐进时间复杂度为指数函数限界的算法称为指数时间算法（exponential time algorithm）
常见多项式时间算法的渐进时间复杂度之间的关系：

\[O(1)<O(log n)<O(n)<O(nlogn)<O(n^2)<O(n^3) \]

常见的指数时间算法的渐进时间复杂度之间的关系为：

\[O(2^n)<O(n!)<O(n^n) \]

3. 递推关系

递推方程（recurrence equation）是自然数上一个函数\(T(n)\)，它使用一个或多个小于\(n\)的值的等式或不等式来描述，也称递推关系或递推式。递推方程必须有一个初始条件（也称边界条件）。

计算递推式通常有三种方法：迭代方法（iterating）、替换方法（substitution）和主方法（master method）。

  1. 替换方法
    替换方法要去首先猜测递推式的解，然后用归纳法证明。

  2. 迭代方法
    迭代方法的思想是扩展递推式，将递推式先转换成一个和式，得到渐进复杂度。

  3. 主方法
    主定理：设\(a\geq 1\)和\(b>1\)为常数，\(f(n)\)是一个函数，\(T(n)\)由下面的递推式定义：

    \[T(n) = aT(n/b)+f(n) \]

    式中，\(n/b\)指\(\lfloor n/b\rfloor\)或\(\lceil n/b \rceil\)，则\(T(n)\)有如下的渐进界：

    （1）若对某常数\(\epsilon>0\)，有\(f(n) = O(n^{log_b^a-\epsilon})\)，则\(T(n) = \Theta(n^{log_b^a})\)；
    （2）若\(f(n) = \Theta(n^{log_b^a})\)，则\(T(n) = \Theta(n^{log_b^a}logn)\)；
    （3）若对某常数\(\epsilon >0\)，有\(f(n) = \Omega(n^{log_b^{a+\epsilon}})\)，且对某个常数\(c<1\)和所有足够大的\(n\)，有\(af(n/b)\leq cf(n)\)，则\(T(n) = \Theta(f(n))\)。

练习

  1. 矩阵转置
    （1）设计一个C/C++程序实现一个\(n\times m\)的矩阵转置。原矩阵保存在二维数组中。
    （2）使用全局变量count，改写矩阵转置程序，并运行修改后的程序，以确定改程序的程序步
    （3）计算此程序的渐进时间复杂度
  2. 证明：若\(f(n) = a_mn^m+a_{m-1}n^{m-1}+\cdots+a_1n+a_0\)是\(m\)次多项式，且\(a_m>0\)，则\(f(n)=\Omega(n^m)\).
  3. 运用主定理求\(T(n) = 2T(n/4) + \sqrt{n}, T(1) = 3\)的渐进界

伸展树与跳表

伸展树

二叉搜索树（binay search tree）是一颗二叉树，它要求根的左子树上的所有结点的值都小于根的值，右子树上所有的结点的值都大于根的值，并且左右子树都是二叉搜索树。

字典（dictionary）是词条的集合，词条包括关键字（key）和其他信息。字典作为一种数据结构，主要包括搜索、插入和删除等基本运算。

字典可以用二叉搜索树来表示，但该结构容易出现退化树形，使得搜索和修改的代价增大。二叉平衡树（binary balanced tree）是一种平衡搜索树，他需要在每次插入和删除元素之后，按规则重新平衡树形，使之始终保持平衡，从而限制树的高度，避免退化。

伸展树（splay tree）是一颗二叉搜索树，但要求每访问一个元素后，将最新访问的元素移到二叉搜索树的根部，从而保证经常被访问的元素靠近根节点，而较少访问的元素位于搜索树较低的层次上。所以这是一种自调整搜索树（self-adjusting search tree）。这种将一个元素移至根部的操作称为一次伸展（splay）。

在伸展树中，虽然某次运算（搜索、插入或删除）可能很费时，需要\(O(n)\)时间，但执行一个\(m(m\geq n)\)次的长运算序列，花费的总时间为\(O(m\log n)\)（n是树中的元素个数），每个运算的平均分摊代价为（\(O(\log n)\)）。

一颗伸展树是一颗二叉搜索树。它的搜索、插入和删除运算的算法与普通的二叉搜索树完全相同，只是在每次运算执行后，需要紧跟一次伸展操作。伸展操作结束，伸展结点成为树的根节点。可以按下列方式来确定伸展树运算的伸展结点。

  1. 搜索运算：搜索成功的结点x为伸展结点；
  2. 插入操作：新插入的结点x为伸展结点；
  3. 删除操作：被删除的结点x的双亲为伸展结点；
  4. 若上述运算失败终止，则搜索过程中遇到的最后一个结点为伸展结点。

一次伸展操作由一组旋转（rotation）动作组成，可分为单一旋转（single rotation）和双重旋转（double rotation）两类。

设q是本次伸展的伸展结点，

  1. 单一旋转

    若q是p的左孩子或者q是p的右孩子，则执行单一旋转。前者称为zig旋转（右旋转），后者称为zag旋转（左旋转）。经过一次单一旋转，树的高度并未减小，只是将伸展结点向上移了一层。

  2. 双重旋转

    1. 第一种双重旋转称为一字旋转。如果伸展结点q是祖父结点的左孩子的左孩子，或是其祖父结点的右孩子的右孩子时，则执行双重旋转的一字旋转。前者称为zigzig旋转，后者称为zagzag旋转。经过一次一字旋转，树的高度并未减小，只是把伸展结点q的位置向上移了两层。
    2. 第二种双重旋转称之为之字旋转。如果伸展结点q是祖父结点的左孩子的右孩子，或是其祖父结点的右孩子的左孩子时，则执行双重旋转的之字旋转。前者称为zigzag旋转，后者称为zagzig旋转。经过一次之字旋转，树的高度减少1，且伸展结点q的位置上移，离根的距离减少了两层。

定义（秩）：设x是伸展树T中的一个结点，\(s(x)\)是以x为根的子树的结点数，结点x的秩（rank）\(r(x)\)定义为：\(r(x)=\log\ s(x)\)

定义（势能）：设x是伸展树T中的一个结点，伸展树T的势能（potential）\(\phi\)定义为树中所有结点的秩之和：\(\phi=\sum_{x\in T}r(x)\)

定义（分摊代价）：设对伸展树T执行m次运算，第i次运算的分摊代价\(\widehat{c}_i\)定义为：\(\widehat{c}_i=c_i+\phi_i-\phi_{i-1}\)

定理：在一个有n个结点的伸展树上，执行一次运算i（搜索、插入或删除），其伸展结点为q，所需的分摊代价为：

\[\hat{c}_i=1+3\log\ n \]

定理：对一颗结点数目不超过n的伸展树，执行m次运算（搜索、插入或删除）的实际总代价不会超过：

\[m(1+3\log n)+n\log n \]

跳表

跳表是一个有序链表，每个结点包含可变数目的链（指针），节点中的第i层链，跳过那些只包含低于第i层链的结点，构成一个单链表。每隔\(2^i\)个元素就有一个i级指针。第0层链是包含所有元素的有序链表，第1层链是包含第0层链的子集，......，第i层链包含的元素是i-1层链的子集。在理想情况下，跳表的层数是\({\left \lceil \log n \right \rceil}\)。

对于一个有n个结点的跳表有如下结论：

  • 第k层至少有一个元素的概率至多是\(n/2^k\)。

  • 定理：跳表的高度（即最大级数）大于k的概率至多为\(n/2^k\)。

  • 定理：n个元素的跳表的平均空间复杂度为\(O(n)\)。

基本搜索和遍历方法

基本概念

搜索（search）是一种通过系统地检查给定数据对象的每个结点，寻找一条从开始结点到答案结点的路径，最终输出问题的求解方法。

遍历（traversal）方法要求系统检查数据对象的每个结点。根据被遍历的数据对象的结构不同，可分为树遍历和图遍历。

无知搜索（uninformed search）也称盲目搜索（blind search）或穷举搜索（brute search），是最简单的搜索状态空间树（图）的方法。

有知搜索（informed search）对应于无知搜索，采用经验法则（rules of thumb）的搜索方法称为启发式搜索（heuristic search）。

深度优先搜索（depth first search）和广度优先搜索（breadth first search）是两种基本的盲目搜索方法，介于两者之间的有D-搜索（depth search）。

搜索方法

将被搜索的数据结构中的结点按其状态分为4类：未访问、未检测、正扩展和已检测。

一个结点x如果尚未访问，则它处于未访问（unvisited）状态；如果x自身已访问，但x的后继结点尚未全部访问，则称x处于未检测（unexplored）状态；当算法访问了x的所有后继结点时，就称x已由此算法检测，处于已检测（explored）状态；所谓检测一个结点x是指算法正从x出发，访问x的某个后继结点y，x被称为扩展结点（being expanded），简称E-结点。一旦y被访问后，y便成为未检测结点。在算法执行的任意时刻，最多只有一个结点为E-结点，但可以有多个结点处于未检测状态。

根据如何选择E-结点的规则不同，得到两种不同的搜索算法：深度优先搜索和广度优先搜索。

  • 如果对于一个未检测结点，一个搜索算法必定在访问它的全部后继结点后（使得该E-结点成为已检测结点后），才选择另一个未检测结点（作为扩展结点），检测它，这种做法称为广度优先搜索。
  • 如果一个算法一旦访问了某个结点，该结点成为未检测结点后，便立即被算法检测，成为E-结点，而此时，原E-结点尚未检测完毕，仍处于未检测状态，需要在以后适当时候才得以继续检测，这种做法称为深度优先搜索。

称未检测结点为活结点（life node），称已检测结点为死节点（dead node）。在搜索算法的执行中，需要有一个数据结构保存这些活结点，被称为活结点表（life node list）。

深度优先搜索需要用堆栈作为活结点表，而广度优先搜索的活结点表通常是先进先出的队列。如果一个搜索算法既按广度优先搜索方式选择E-结点，又使用堆栈为活结点表，则称之为D-搜索，它是广度和深度两者的结合。

posted @ 2018-01-08 20:32  main_c  阅读(1290)  评论(0)    收藏  举报