数据结构 第八章 排序 习题

8.1 排序的定义

排序分类

内部排序

排序期间元素全部存放在内存中的排序

插入（直接插入排序、折半插入排序、希尔排序）；交换排序（冒泡排序、快速排序）；选择排序（简单选择排序、堆排序）；归并排序；基数排序

外部排序

排序期间元素无法全部同时存放在内存中，必须在排序的过程中根据要求不断地在内、外存之间移动
多路归并排序

算法的稳定性

若待排序表中有两个元素$R_j$和$R_j$，其对应的关键字相同，且在排序前$R_i$在$R_j$前面，若使用某一排序算法排序后，$R_i$仍在$R_j$前面，则称这个排序算法是稳定的，否则称排序算法是不稳定的。

习题8.1

1. 拓扑排序是将有向图中所有结点排成一个线性序列，在内存中进行，但不满足排序定义，不属于内部排序，也不属于外部排序。
2. 对于任意基于比较的排序，比较次数至少为$\lceil lo{g}_2^{(n!)}\rceil$

8.2 插入排序

直接插入排序

待排序表L[1…n]在某次排序过程中的某一时刻状态下：

要将元素L(i)插入到已有序的子序列L[1…i-1]中，需要执行以下操作：
1）查找出L(i)在L[1…i-1]中的插入位置k
2）将L[k…i-1]中的所有元素依次后移一个位置。
3）将L(i)复制到L(k)

void InsertSort(ElemType A[], int n){
   
	int i,j;
	for(i=2;i<=n;i++){
   
		if(A[i]<A[i-1]){
   
			A[0]=A[i];	//哨兵
			for(j=i-1;A[0]<A[j];--j)	//从后往前查找待插入位置
				A[j+1]=A[j];
			A[j+1]=A[0];
		}
	}
}

结合上代码具体实现过程演示（可能有小错误，R2这轮应该是不用的）

算法性能分析

• 空间效率：常数个辅助单元，$O(1)$
• 时间效率：在排序过程中，向有序子表中逐个地插入元素的操作进行了$n-1$趟，每趟操作都分为比较和移动，比较次数和移动次数取决于初始状态。
  最好情况：表中有序，只需比较，不需要移动，$O(n)$；
  最坏情况：表为逆序，比较次数为${\sigma }_{i=2}^{n}i$，移动次数为${\sigma }_{i=2}^n(i+1)$，$O(n^2)$；
  平均情况：取上述最好与最坏情况的平均值，$O(n^2)$。
• 稳定性：稳定。
• 适用性：顺序和链式都可以。

折半插入排序

直接插入排序算法的改进，将比较和移动操作分离，先折半查找出元素待插入位置，然后统一地移动待插入位置之后的所有元素。

void InsertSort(ElemType A[], int n){
   
	int i,j,low,high,mid;
	for(i=2;i<=n;i++){
   
		A[0]=A[i];
		low=1;
		high=i-1;
		while(low<=high){
   	//折半查找
			mid=(low+high)/2
			if(A[mid]>A[0])
				high=mid-1;
			else
				low=mid+1;
		}
		for(j=i-1;j>=high+1;--j)
			A[j+1]=A[j];
		A[high+1]=A[0];
	}
}

算法性能分析

• 空间复杂度：$O(1)$；
• 时间复杂度：比较次数为$O(nlo{g}_2^n)$，且与初始状态无关，仅取决于表长，但移动次数未改变，时间复杂度为$O(n^2)$
• 稳定性：稳定

希尔排序

希尔排序的基本思想是：先将待排序表分割成若干形如$L[i,i+d,i+2d,...,i+kd]$的“特殊”子表，即把相隔某个“增量”的记录组成一个子表．对各个子表分别进行直接插入排序，当整个表中的元素已呈“基本有序”时，冉对全体记录进行一次直接插入序。
希尔排序的过程如下：先取一个小于$n$的步长$d_1$。把表中的全部记录分成$d_1$组，所有距离为的倍数的记录放在同一组，在各组内进行直接插入排序；然后取第二个步长$d_2<d_1$，重复上述过程，直到所取到的$d_t=1$,即所有记录已放在同一组中，再进行直接插入排序，由于此时己经具有较好的局部有序性，故可以很快得到最终结果。到目前为止，尚未求得一个最好的增量序列，希尔提出的方法是$d_1=n/2,d_{i+1}=\lfloor d_i/2\rfloor$，并且最后一个增量等于1。

void ShellSort(ElemType A[], int n){
   	
	for(dk=n/2;dk>=1;dk=dk/2){
   	//步长
		for(i=dk+1;i<=n;++i){
   
			if(A[i]<A[i-dk]){
   
				A[0]=A[i];
				for(j=i-dk;j>0&&A[0]<A[j];j-=dk)
					A[j+dk]=A[j];
				A[j+dk]=A[0];
			}
		}
	}
}

希尔排序（这边每轮的d均为上一轮除以2并向上取整，因此比书上多一轮）

算法的性能分析

• 空间效率：$O(1)$；
• 时间效率：由于希尔排序的时间复杂度依赖于增量序列的函数，当n在某个特定范围时，希尔排序的时间复杂度为$O(n^{1.3})$，在最坏情况下希尔排序的时间复杂度为$O(n^2)$；
• 稳定性：不稳定；
• 适用性：仅适用于顺序存储。

交换排序

冒泡排序

冒泡排序的基本思想是：从后往前（或从前往后）两两比较相邻元素的值，若为逆序（即A[i-1]>A[i])，则交换它们，直到序列比较完。我们称它为第一趟冒泡，结果是将最小的元素交换到待排序列的第一个位置（或将最大的元素交换到待排序列的最后一个位置)，关键字最小的元素如气泡一般逐渐往上“漂浮”直至“水面”（或关键字最大的元素如石头一般下沉至水底).
下一趟冒泡时，前一确定的最小元素不再参与比较，每冒泡的结果是把序列中的最小元素（或最大元素）放到了序列的最终位置……这样最多做n-1趟冒泡就能把所有元素排好序。

void BubbleSort（ElemType A[], int n){
   
	for(i=0;i<n-1;i++){
   
		flag=false;
		for(j=n-1;j>i;j--)
			if(A{
   j-1]>A[j]){
   
				swap(A[j-1],A[j]); //交换函数
				flag=true;
			}
		if(flag==false)	//当遍历后没有发生交换，说明表已经有序
			return;
	}
}

• 空间效率：$O(1)$；
• 时间效率：
  最好情况下，初始序列为顺序，只需比较$n-1$次，移动0次，$O(n)$；
  最坏情况下，初始序列为逆序，需要进行n-1趟冒泡排序，第i趟排序需要进行$n-i$次关键字比较，而且每次比较后都必须移动3次来交换元素，这样情况下比较次数为${\sigma }_{i=1}^{n-1}(n-i)=\frac{}{2}$