【408数据结构】排序

排序

如果没有特别说明，都默认是非递减。

插入排序

直接插入排序

分为内层循环和外层循环。

在内层循环中，选定一个$a_i$，并且不断迭代，直到寻找到一个元素比其小，插入进其后边。

外层循环，不断迭代$i$。

【特性：在第$i$轮结束后，保证了数组前面$i$个元素有序。】

代码实现

void insert_sort(int a[], int n)// a: 待排序数组， n: 数组长度（数组下标从1开始：1——n）
{
	for (int i = 2; i < n; i++)
	{
		a[0] = a[i];
		int j = i, q;
		while(j >= 1 && a[j] > a[0])
		{
			j--;
		}
		for (q = i; q < j; q--)
		{
			a[q] = a[q-1];
		}
		a[q] = a[0];
		// ============王道的例子=============
		for (j = i - 1; a[0] < a[j]; j--)
			a[j+1] = a[j];
		a[j+1] = a[0];
		// ===================================
	}
}

效率分析

Name	复杂度	情况
空间	$O(1)$
时间	$O(N^2)$
比较次数：最好	$n$	本身已经有序，每个项比较一次就行
比较次数：最坏	${\sum }_{i=2}^n(i+1)$	逆序，每一次都比较到头
比较次数：平均	$n^2/4$	取上面二者平均值：书上原话
稳定性		稳定
可用在链表？		是

折半插入排序

利用折半查找的思想，将折半查找用在找到插入到的位置的直接前驱。

非重点。因为折半查找，仅仅减小了查找的次数，而没有减少移动的次数。

其效率还是和直插一样。

划重点：它的最好的时间时间复杂度是$O(\log n)$而不是$O(n)$：因为在直插的最好情形中，直插仅仅需要一次的关键字比对；而它却需要$\log n$次比对

void insert_binary_sort(int 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] = a[j + 1];
		}
		a[low] = a[0];
	}
}

希尔排序

非重点（因为求不出具体的时间复杂度。算最坏的，也是$O(n^2)$，可替代性很强【也就是说，除非点名，不知道代码的话，用其余算法的替代】）

仅仅需要知道过程。

名词解释：增量$d_i$——每一轮中，取$d_i$为间隔的为一组。（也就是下图红线横跨了多少个。）

将一个序列进行多次循环迭代，每一轮的迭代对应着一个$d_i$；然后对处在这个增量下的一个子序列，进行一次直接插入排序。

交换排序

交换排序，根据元素中两两比较的结果，进行对换。

冒泡排序

两两比对，交换

每一轮的排序，都是使得一个最大（或者最小）确定位置。

效率分析

Name	复杂度	情况
空间	$O(1)$
时间	$O(N^2)$
比较次数：最好	$n-1$	本身已经有序，每个项比较一次就行
移动次数：最好	0	本身就有序，然后一比较，没有元素进行交换
比较次数：最坏	${\sum }_{i=1}^{n-1}(n-i)$	逆序，每一次都比较到头
移动次数：最坏	${\sum }_{i=1}^{n-1}3(n-i)$	每次交换，涉及到了三个元素的移动（swap带来的）
比较次数：平均	$O(N^2)$
稳定性		稳定
可用在链表？		是

快排✨✨✨

快排，又称救命排序。遇事不决，就快排。

基于分治法，选定一个枢纽pivot，将数组分成了两部分，以致左边的元素都小于pivot，右边都大于pivot；并且将pivot放在对应的位置上。

效率分析

Name	复杂度	情况
空间	$O(\log n)$或者$O(n)$	最坏时，⁍：此时一轮只确定了一个枢轴的位置
时间	$O(N\log N)$	平均情况or最好情况
	$O(N^2)$	最坏情况
比较次数：平均	$O(N^2)$
稳定性		不稳定
可用在链表？		否

代码实现

void quicksort(int a[], int low, int high)
{
	if(low < high){
		pivotpos = partition(a, low, high);
		quicksort(a, low, pivotpos - 1);
		quicksort(a, pivotpos + 1, high);
	}
}

int partition(int a[], int low, int high)
{
	int pivot = a[low];
	while (low < high)
	{
		// 王道的留空版
		while(low < high && a[high] >= pivot) --high;
		a[low] = a[high];
		while(low < high && a[low] <= pivot) ++low;
		a[high] = a[low];

		// 408快乐站版
		while(low < high && a[high] >= pivot) --high;
		while(low < high && a[low] <= pivot) ++low;
		swap(a[low], a[high]);
		
	}
	a[low] = pivot;
	// 对应的408快乐站版 : 因为此时，j在i的左边了
	swap(a[low], a[j]);
	return low;
}

算法题考法

快排不仅可以用在排序，更重要的是划分的思想。将数组的元素一分为二，使xxx在前，xxx在后。

int partition(int a[], int n)
{
	int i = 0, j = n - 1;
	while(i<j)
	{
		while(a[i] % 2 == 1 && i < j) i++;
		while(a[j] % 2 == 0 && i < j) j--;
		swap(a[i],a[j]);
		i++, j--;
	}

}

选择排序

历年的选择都是考察堆。选择排序太简单了

简单选择排序

选最小或者最大，然后放在循环。

堆排序

1. 建堆：
   

   关键：从分支结点【int (n/2)】开始，用一个下坠的loop，到根节点为止：

2. 互换

   要建大根堆，则把顶部（根节点）【i.e.最大元素】换到最末

3. 调整【本质还是新的根节点不断下坠的过程】
   

4. 添加结点

   1. 添加位置是在堆底！最后一个最末！
   2. 然后用3.的调整【本质是新的根节点不断上升的过程】

5. 删除结点

   首先删除结点，然后让子孩子来补充（具体是哪个孩子，取决于两者的大小和这是个大顶堆还是小顶堆）

归并排序和基数排序

二路归并排序

基于分治，将当前列表一分为二。

要记住，二路归并的图图！

并且假定，两个子表已经有序。

int *b = malloc((n+1)*sizeof(int));
int Merge(int a[], int low, int mid, int high)
{
	int i, j; // 变量
	for(int k = low; k <= high)
		b[k] = a[k];
	for(i = low, j = mid + 1, k = low; i <= mid && j <= high; k++)
	{
		if(b[i] < b[j]) // 选低的部分
			a[k] = b[i++];
		else
			a[k] = b[j++];
	}
	// 以下两个循环只会执行一个
	while(i <= mid) a[k++] = b[i++];
	while(j <= high) a[k++] = b[j++];
}

void mergeSort(int a[], int low, int high)
{
	if(low < high)
	{
		mergeSort(a, low, (low+high)/2);
		mergeSort(a, (low+high)/2 + 1, high);
		Merge(a, low, (low+high)/2, high);

	}

}

基数排序

基数排序中，主要依赖两个操作：分配和收集。

• MSD：先从高位开始进行排序，在每个关键字上，可采用计数排序
• LSD：先从低位开始进行排序，在每个关键字上，可采用桶排序

分配：考察每个结点元组第$i$个位置，按先后顺序，将结点插入对应的链接表中。

记住，是队列，因此是先进先出：头是第一个，尾是第二个。

时间复杂度：$O(d(n+r))$

使用场景：d,r较小，较大

$$\begin{gathered} \mathrm{d}:分配、收集的趙数 \\ \mathrm{n}:数据元素个数 \\ \mathrm{r}:有多少个队列 \end{gathered}$$

一般不会考代码，但是要会手动模拟。

外部排序

名词解释
时间代价：主要是磁盘的IO的次数
外部排序的总时间：内部排序所需时间+外存信息所需时间+内部归并所需时间

外部排序方法

1. 生成初始归并段
2. 经历$S$趟排序

方法其实可能相对来说不重要，有个大概印象就行

计算问题

假设，对$r$个初始归并段（也就是说， 段内部已经归并好了），做$k$路平衡。

一个$k$叉树。

趟数$S=\lceil {\log }_{k}r]$

结论：$k$越大，$S$越少，磁盘读写IO次数越低。

但$k$并不是越大越好。因为内部归并的比较次数与$k$有关，并且其时间开销会抵消增大$k$所获得的效益。因而提出了败者树的概念。

败者树

（不太重点）

使用败者树之后，内部归并的比较次数与$k$无关。

置换、选择排序

得到了一个长度不等的初始归并段。

最佳归并树

💡 组织这样长度不等的初始归并段，然后进行归并。那这样会形成一个问题：如何组织一场最优的归并？

结点权值：标识该段长度。

WPL：带权路径之和；归并树的WPL=归并过程中的总读记录数，故IO=2*WPL。

最佳归并树：其WPL最小。

得到的方法：哈夫曼树的拓展

虚段：不足以形成哈夫曼树时，凑数用的

哈夫曼树：严格$k$叉树
$n_0=(k-1)n_k+1\to (n_0-1)/(k-1)=n_k$

补充$n_0$至适宜。

$(n_0-1)\%(k-1)=u\ne 0$，说明有$u$个点是多余的。因此，只需要补充$k-1-u$个结点就行了。（记住结论。）