【C语言】八大排序实现及稳定性和总结

---

一、八大排序剖析链接

以下是各大排序的剖析，点击文字会跳转到对应的文章。

插入排序、希尔排序、堆排序、快速排序
归并排序、选择排序、冒泡排序、计数排序

二、排序的稳定性

在未排序的数据中，有多个相同数据，若经过排序后，相对顺序保持不变。
未排序，r[a] = r[b]，r[a]在r[b]位置前面，排序后，r[a]仍在r[b]前面，说明该排序算法是稳定的，相对顺序改变就不稳定。

2.1 稳定性作用

比如：考试提交成绩的时候，如果两个学生的成绩都是满分，就会按照提交时间来排名，特别是在评奖的时候，保持公平性。
排序稳定的作用就体现出来了，可以保证先提交的一定在前面，后提交的在后面。反之不稳定就可能出现后提交在前。

2.2 如何判断排序算法是否稳定

举一些针对性的例子，特别注意交换过程和比较条件、该排序算法的特性。

---

插入排序：稳定，因为只有新数据比有序数据小才会移动，相等的情况并不会移动。

希尔排序：不稳定，由于数据会进行分组，在每组进行排序，导致相同的数据会分到不同的组进行预排序，相对顺序就不能保证

• 如：3，3，1，7，2，9，gap为2，第一个3在该组为最大，第二个3在该组为最小，分组排序的时候就会把第一个3，放到第二3的后面。

堆排序：不稳定，数组中有和堆顶一样的数，堆顶和最后一个交换的时候，相对顺序就会被破坏，因为在顶上的数据会先被交换下来。

快速排序：不稳定，如果选的key，在数据中有一样，就会造成不稳定，因为key会排到正确的位置过程中无法控制相同的值，相同的值在左右两边都可以，key最后不知道放在哪里了。

归并排序：稳定，每次合并的时候都是一个个的合并，两个数据相同，可以让第一个序列先归并。合并顺序是可以调整的。

选择排序：不稳定，在选最小（大）值的时候，被交换的值有相等的值，就会不稳定。

冒泡排序：稳定，当前数据比下一个数据小（大），才交换，相等不会交换。

---

总结

---

三、八大排序实现及源代码

3.1 插入排序

实现思路：

1. 假设第一个数据（下标0）有序，后面的n-1个数据都需要插入到有序数组里
2. 保存有序数据后面一个数据（tmp）
3. 移动数据，需要把新数据插入有序数据中的合适位置（tmp < end）
4. 移动数据停止条件有两个：

• 最坏情况：tmp比全部有序的数据要小，有序数据从头到尾都需要移动，end移动到-1，说明移动完成。
• 当tmp > end下标的数据，说明已经有序了。

5. 插入数据到end+1的下标位置，因为end下标的数据是小于tmp。

代码：

// 插入排序（升序）
void InsertSort(int* a, int n)
{
   
   	
	// i迭代n - 1结束，到n结束会越界，因为需要访问未排序的数据（i+1 == n+1），就会越界
	for (int i = 0; i < n - 1; i++)
	{
   
   
		
		int end = i;	// 有序的个数
		int tmp = a[end + 1];	// 需要插入的新数据（未排序的数据）
		
		// 新的数据想要插入都有序数据中，需要移动数据，插入到合适的位置
		// 以升序为例，最坏情况：新数据比全部有序的数据要小，有序数据都需要移动
		while (end >= 0)
		{
   
   
			// 新数据小于有序数据就要移动数据
			if (tmp < a[end])
			{
   
   
				a[end + 1] = a[end];
				end--;
			}
			else
			{
   
   
				// 已经有序
				break;
			}
		}
		// 插入数据到end+1的下标位置，end < tmp
		a[end + 1] = tmp;
	}
}

3.2 希尔排序

实现思路：
先选定一个整数（gap），把待排所有数据分成gap个组，所有距离为差相同的数据分在同一组内，并对每一组内的记录进行排序。然后缩小gap，重复上述分组和排序的工作。当到达gap=1时，所有数据在统一组内排好序。

• 预排序 gap > 1，目的是让数据接近有序
• 直接排序 gap = 1，目的是数据有序

代码：

// 希尔排序（升序）
void ShellSort(int* a, int n)
{
   
   
	int gap = n;
	while (gap > 1)
	{
   
   
		// 缩小gap，最后加1，是确保最后gap=1，为直接插入排序
		gap = gap / 3 + 1;
		
		// 一次排多组差距为gap的数据
		for (int i = 0; i < n - gap; i++)
		{
   
   
			int end = i;
			int tmp = a[end + gap];
			
			while (end >= 0)
			{
   
   
				if (a[end] > tmp)
				{
   
   
					a[end + gap] = a[end];
				}
				else
				{
   
   
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

3.3 堆排序

1. 建堆，排升序：建大堆，排降序：建小堆

• 通过向下调整，从倒数第一个非叶子节点开始调整

2. 堆结构建立完，就排序

• 堆顶的数据和最后一个数据交换，排好的数据排除掉（缩小区间，end–），在重新向下调整把次大的数据放到堆顶，直到堆顶结束（end>0）

代码：

// 交换
void Swap(int* pa, int* pb)
{
   
   
	int tmp = *pa;
	*pa = *pb;
	*pb = tmp;
}

// 向下调整
// 大堆
void AdjustDown(int* a, int n, int parent)
{
   
   
	int child = parent * 2 + 1;
	
	while (child < n)
	{
   
   
		// 找左右孩子最大的
		// 防止越界：右孩子可能不存在
		if (child + 1 < n && a[child] < a[child + 1])
		{
   
   
			child++;
		}
		
		// 孩子比父亲大就交换
		if (a[child] > a[parent])
		{
   
   
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
   
   
			// 堆结构正常
			break;
		}
	}
}

// 堆排序
void HeapSort(int* a, int n)
{
   
   
	// 建大堆，从最后非叶子结点开始到第一个结点
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
   
   
		AdjustDown(a, n, i);
	}

	// 排序，选出最大的交换到最后，在缩小区间（排除已排好的数据）
	int end = n - 1;
	while (end > 0)
	{
   
   
		Swap(&a[0], &a[end]);	// 交换
		AdjustDown(a, end, 0);	// 找出次大的，放到堆顶
		end--;					// 已经排好的数据，给排除
	}
}

3.4 快速排序

3.4.1 Hoare版（左右指针法）

1. 记录key位置，一般最左边或最右边以此作为分区条件，左右两个指针从两端开始往中间走
2. right先走，找到比key小的值停下，left后走，找到比key大的值停下。
3. left停止后，说明left的值比key大和right的值比key小，两个数据交换，大的在右边，小的就在左边
4. left和right相遇时，需要将key和相遇位置的交换，目的达成，key比左边的值要大，比右边的值要小
5. 重复以上操作，直到最后左右区间不存在或者只有1个数，排序就完成了

代码：