算法设计与分析期末复习（一）

算法的定义和特征

1. 什么是算法？
   算法是求解某一特定问题的一组有穷规则的集合，它是由若干条指令组成的有穷符号串。
2. 算法的五个重要特性
   确定性：算法中每一条指令必须有确切的含义，不存在二义性。只有一个入口和一个出口。
   可行性：算法描述的操作可以通过已经实现的基本运算来执行有限次来实现。
   输入：一个算法有零个或多个输入。
   输出：一个算法有一个或多个输出。
   有穷性：一个算法必须在执行有穷步之后结束，且每一步都在有穷时间内完成。
3. 算法设计的质量指标
   正确性，可读性，健壮性，效率与存储量

算法和程序的区别

算法的有穷性意味着不是所有的计算机程序都是算法

算法复杂性

算法复杂性=计算机所需要的计算机资源=时间复杂度+空间复杂度
一般只考虑三种情况下的时间复杂性：最坏情况、最好情况和平均情况的复杂性。
Tmax(n)、Tmin(n)和Tavg(n)

1. 上界函数
   f(n) = O(g(n))
   若算法用n值不变的同一类数据在某台机器上运行，所用的时间总是小于|g(n)|的一个常数倍。所以g(n)是f(n)的一个上界函数。f(n)的增长最多像g(n)的增长那样快。
   求最小的g(n)
2. 下界函数
   f(n) = Ω(g(n))
   若算法用n值不变的同一类数据在某台机器上运行，所用的时间总是不小于|g(n)|的一个常数倍。所以g(n)是f(n)的一个下界函数。f(n)的增长至少像g(n)的增长那样快。
   求最大的g(n)
3. 平均情况限界函数
   f(n) = θ(g(n))

常见的多项式限界函数
Ο(1) < Ο(logⁿ) < Ο(n) < Ο(nlogⁿ) < Ο(n²) < Ο(n³)
常见的指数时间限界函数
O(2ⁿ) < O(n!) < O(nⁿ)
当n取值较大时，指数时间算法和多项式时间算法在计算时间上非常悬殊。

最优算法
问题的计算时间下界为Ω(f(n))，则计算时间复杂性为O(f(n))的算法是最优算法。
排序问题的计算时间下界是Ω(nlogⁿ)，则计算时间复杂性为O(nlogⁿ)的排序算法是最优算法。

递归

递归算法：直接或间接的调用自身的算法
递归函数：函数自身给出定义的函数

1. 基于归纳法的递归
   Fibonacci数列
   无穷数列1，1，2，3，5，8，13，21，34，55，……，称为Fibonacci数列。
   可递归定义为：
   
   第n个Fibonacci数计算：

int fibonacci(int n){
	if(n<=1){
		return 1;
	}else{
		return fibonacci(n-1)+fibonacci(n-2);
	}
}

优点：结构清晰，可读性强，而且容易用数学归纳法来证明算法的正确性，因此它为设计算法，调试程序带来很大方便。
缺点：递归算法的运行效率低，无论是耗费的计算时间还是占用的存储空间都比费递归算法高。
2. 基于分治法的递归

分治法

将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。

分治法所能解决的问题一般具有以下几个特征：

1. 该问题的规模缩小到一定的程序就可以容易地解决。
2. 该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质。
3. 利用该问题分解出的子问题的解可以合并为该问题的解。
4. 该问题分解出的各个子问题是相互独立的，即子问题不包含公共的子问题。

分治法的基本步骤：

1. 分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题。
2. 解决：若子问题规模较小而容易地解决则直接解，否则递归地解各个子问题。
3. 合并：将各个子问题的解合并为原问题的解。

分治法的复杂性分析——Master定理
分治法将规模为n的问题分解成k个规模为n/k的子问题。设分解阈值n=1，将原问题分解为k个子问题以及用merge将k个子问题的解合并成原问题的解需要f(n)个单位时间。

二分搜索

给定已按升序排好序的n个元素a[0:n-1]，现在要从n个元素中找出一特定元素x

int binarySearch(int a[],int &x,int l,int r){
	while(l <= r){
		int mid = (l+r)/2;
		if(a[mid] == x){
			return mid;
		}else if(a[mid] < x){
			l = mid + 1;
		}else{
			r = mid - 1;
		}
	}
	return -1;
}

算法复杂性分析：
每次执行一次算法的while循环，待搜索数组的大小减少一半。
最坏情况下，执行O(logⁿ)次。

合并排序

将待排序的元素分成大小大致相同的2个子集合，分别对2个子集合进行排序，最终将排好序的子集合合并成为所要求的排好序的集合。

void mergeSort(int a[],int l,int r){
	if(l < r){ //至少有两个元素
		int m = (l+r)/2;
		mergeSort(a,l,m);
		mergeSort(a,m+1,r);
		merge(a,b,left,m,r);//合并到数组b
		copy(a,b,l,r); //复制回数组a
	}
}

void qSort(int p,int r)
{
	if(p < r){
		int q = partition(p,r); //以a[p]为基准元素将a[p:r]划分成3段a[p:q-1]，a[q]和a[q+1:r]，下标q再划分过程中确定。
		qSort(p,q-1);
		qSort(q+1,r);
	}
}

int partition(int a[],int p,int r){
	int i = p;
	int j = r + 1;
	int x = a[p];
	while(true){
		while(a[--j] >= x);
		swap(a[i],a[j]);
		while(a[++i] <= x && i < r);
		if(i >= j){
			break;
		}
		swap(a[i],a[j]);
	}
	return j;
}

线性时间选择问题

问题描述：给定线性集中n个元素和一个整数k，要求找出n个元素中第k小的元素。当k=1时，找最小元素；k=n时，找最大的元素；k = (n+1)/2，找中位数。

int randSelect(int a[],int start,int end,int k){
	if(start == end) return A[start];
	int i = RandomizedPartition(A,start,end);
	int n = i - start + 1; //左子数组A[start:i]的元素个数
	if(k <= n){
		return randSelect(a,start,i,k);
	}else{
		return randSelect(a,i+1,end,k-n);
	}
}

在最坏情况下，随机线性选择需要O(n²)计算时间。
但可以证明，算法randomizedSelect可以在平均时间O(n)内找出n个输入元素中第k小的元素。

真正的线性时间选择
将n个输入元素划分成n/5，每组5个元素，只可能有一个组不足五个元素。用任意一种排序算法，将每组中的元素排好序，并取出它们每组中的中位数，共n/5个。
递归调用Select找出这n/5个元素的中位数，如果个数是偶数，就选取较大的一个作为划分基准。

int Select(int a[], int start, int end, int k){
	if(end-start < 30){
		用某个简单排序算法对数组a[start:end]排序;
		return a[start+k-1];
	}
	for(int i = 0; i <= (end-start-4)/5; i++){
		将a[start+i*5]到a[start+i*5+4]的第3小元素与a[start+i]交换位置;
	}
	//找出中位数的中位数
	int x = Select(a,start,start+(end-start-4)/5,(end-start-4)/10);
	int i = partition(a,start,end,x);
	int n = i-start+1;
	if(k <= n){
		return Select(a,start,i,k);
	}else{
		return Select(a,i+1,end,k-n);
	}
}

n个元素的数组调用select()需要T(n)
找中位数的中位数需要T(n/5)
使用基准得到两个子数组分别最多有3n/4个元素

循环赛日程表问题

分治法策略：将所有的选手分为两半，n个选手的比赛日程表可以通过n/2个选手设计的比赛日程表决定。
递归地对选手进行分割，直到只剩下两个选手时，只要让这两个选手进行比赛就可以了。