数据结构—排序

排序的概念及其常见的算法

排序的概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。

内部排序：数据元素全部放在内存中的排序。

外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

常见的排序算法

常见排序算法的实现

插入排序

基本思想

直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。

注：核心思想是把一个数插入一段有序区间，保持这段区间有序

直接插入排序

当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。

直接插入排序的实现

void InsertSort(int* a, int n)
{
   
	for (int i = 0; i < n-1; ++i)
	//当i=n-2时，表示前n-1个数有序，将数组下标为n-1的数进行插入
	{
   
		// 单趟插入
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
   
			if (tmp < a[end])
			{
   
				a[end + 1] = a[end];
				--end;
			}
			else
			{
   
				break;
			}
		}
		a[end + 1] = tmp;  
		//无论是end<0时（有序区间的所有数都大于该数）跳出循环还是tmp >= a[end]（有序区间的所有数都小于该数或者有序区间的一部分数都大于该数）时跳出循环，都需要在将要插入的数据，插入到有序区间内。
	}	
}

直接插入排序的特性总结

• 直接插入排序的时间复杂度为O($N^2$)，最坏情况是排升序时该数列为降序（逆序）， 直接插入排序的最好情况是接近顺序有序，时间复杂度为O(N)
• 元素集合越接近有序，直接插入排序算法的时间效率越高
• 时间复杂度：O($N^2$)
• 空间复杂度：O(1)，它是一种稳定的排序算法
• 稳定性：稳定

希尔排序( 缩小增量排序 )

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

希尔排序是先对间隔为gap（gap是几就会分成几组）的分成一组，然后按分组对这gap组数据进行直接插入排序（这个过程是预排序（可以排多趟的），使这组一组数列接近顺序有序），然后再用直接插入排序，使得数列为有序。

注：

• 预排序分组的特点是一个数据挪动一次，不是走一步而是走gap步，数据挪动更快。
• gap越小越接近有序，gap越大越不接近有序，但是gap越小挪动越慢，gap越大挪动越快。
• 当gap == 1时，其实就是直接插入排序。
• 预排序的特点是gap>1，而直接插入排序的特点是gap= 1

希尔排序的实现

void ShellSort(int* a, int n)
{
   
	// gap > 1  预排序
	// gap == 1 直接插入排序
	int gap = n;
	while (gap > 1)  //这部分时间复杂度为O(logN)
	{
   
		gap = gap / 3 + 1;  //推荐这种写法（经过实验测验的）
		//gap = gap / 2;  这个方法也可以不过需要n大于1的，这种写法比上面的写法的预排序次数要多

		//间隔为gap的多组并排
		//该循环控制的是同时走这个gap组数据间隔为gap的插入排序
		for (int i = 0; i < n - gap; ++i)   //这部分时间复杂度为O(N)（无论是gap很大、无序时（循环体内容的时间复杂度为常数而循环次数的时间复杂度为O(N)）还是gap很小，接近有序时都是O(N)）
		{
   
			//对间隔为gap的一组数列进行直接插入排序
			//分组为gap的单趟排序
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
   
				if (tmp < a[end])
				{
   
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
   
					break;
				}
			}

			a[end + gap] = tmp;
		}
	}
}

希尔排序的特性总结

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排序的时间复杂度都不固定：

• 《数据结构(C语言版)》–严蔚敏
  希尔排序的分析是一个复杂的问题,因为它的时间是所取“增量”序列的函数,这涉一些数学上尚未解决的难题。因此，到目前为止尚未有人求得一种最好的增量序列，但大量的研究已得出一些局部的结论。如有人指出，当增量序列为dlta[k]=$2^{t-k+1}$-1时，希尔排序的时间复杂度为O($n^{3/2}$)，其中t为排序趟数，1 ≤ k ≤ t ≤ $log(n＋1)$。还有人在大量的实验基础上推出：当n在某个特定范围内，希尔排序所需的比较和移动次数约为$n^{1.3}$，当n$\to$$\infty$时，可减少到n$($logn${)}^2$。增量序列可以有各种取法，但需注意：应使增量序列中的值没有除1之外的公因子，并且最后一个增量值必须等于1。

• 《数据结构-用面相对象方法与C++描述》— 殷人昆
  gap的取法有多种。最初Shell提出取 gap =n/2 ，gap = gap/2 ，直到 gap = 1，后来Knuth提出取gap = (gap/3) +1。还有人提出都取奇数为好，也有人提出各gap互质为好。无论哪一种主张都没有得到证明。对希尔排序的时间复杂度的分析很困难，在特定情况下可以准确地估算关键码的比较次数和对象移动次数，但想要弄清关键码比较次数和对象移动次数与增量选择之间的依赖关系，并给出完整的数学分析，还没有人能够做到。在Knuth所著的《计算机程序设计技巧》第3卷中，利用大量的实验统计资料得出，当n很大时，关键码平均比较次数和对象平均移动次数大约在$n^{1.25}$到1.6$n^{1.25}$范围内，这是在利用直接插入排序作为子序列排序方法的情况下得到的。
  因为咱们的gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照：O($n^{1.25}$)到O(1.6$n^{1.25}$)来算。

4. 稳定性：不稳定
5. 希尔排序的时间复杂度为O($N^{1.3}$)（官方给的），有些书上说希尔排序的时间复杂度为O(N$logN$)或者O(N${\log }_{3}N$)

选择排序

基本思想

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。

直接选择排序

• 在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
• 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
• 在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

直接选择排序的实现

void SelectSort(int* a, int n)
{
   
	int begin = 0, end = n - 1;
	while (begin < end)
	{
   
		//选出在begin和end区间内最小、大的数
		int mini = begin, maxi = begin;
		for (int i = begin; i <= end; ++i)
		{
   
			if (a[i] > a[maxi])
				maxi = i;

			if