一、排序简介

生活中，我们经常能看到排序的应用。例如，我们在网购商品的时候，经常按销量从高到低排序。
那么这些排序是如何实现的呢？
我们来看看常见的排序算法有哪些：

先来介绍一下关于排序算法的几个概念。
稳定性：相等的元素排序之后相对次序不变
内部排序：数据全在内存中的排序
外部排序：数据太多不能同时在内存中

关于排序算法的代码实现，建议先写单趟，这样较为简单。

下面所有排序算法都以排升序为例。

二、直接插入排序

直接插入排序类似我们平时玩扑克牌的洗牌过程。

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

简单来说，就是从拿到第二张牌开始，开始逐个往前比对，按大小关系插到比对过程中的某张牌的前面或者后面，插完第二张牌后再按相同的比对过程插第三张，以此类推。

如图中，我们手上已经洗好了2、4、5、10四张牌。
再拿到一张7，先跟10比，比10小，所以再往前比对。
跟5比，比5大，所以刚好就把7插到5和10之间。
这样我们手上的牌就从四张有序的牌变成五张有序的牌了。

我们来看一个动图：

该动图完整展现了直接插入排序的过程。
在代码实现中，我们把牌插到哪个位置，这个位置后面的所有元素就要后挪一位。而后挪会覆盖我们拿出来的那张牌原本位置的元素，所以应该先保存待插元素的值。
完整代码如下：

void InsertSort(int* a, int n)
{
	for (int i = 1; i < n; i++)
	{
		//单趟
		int end = i - 1;
		//tmp保存要插入排序的值
		int tmp = a[i];//a[0]是最小有序区间，从a[1]开始排序
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				//后挪
				a[end + 1] = a[end];
				//往前走
				end--;
			}
			else
			{
				break;
			}
		}
		//出循环两种可能，break或者end=-1
		a[end + 1] = tmp;//这两种无一例外都要执行这一句
	}
	//时间复杂度
	//最坏情况  O(N^2)
	//最好情况  O(N)
	//空间复杂度O(1)
}

因此，我们可以发现：

1. 一开始越接近有序，直接插入排序的效率就越高。
2. 直接插入排序后，相等元素的相对次序是不变的，故直接插入排序具有稳定性。

但是从时间复杂度O(N^2)可以看出来，直接插入排序的效率其实并不高。下面介绍直接插入排序的优化版本，也就是希尔排序。

三、希尔排序

希尔排序，又称缩小增量排序。
上文提到，对于直接插入排序，一开始越接近有序，排序的效率越高。
所以，希尔排序的优化方式就是先让数组接近有序。

希尔排序包括两个过程：预排序和直接插入排序。

1. 预排序：让数组先接近有序。
   按照间隔gap分组，进行直接插入排序，可以一组排完再排另一组，也可以多组一起排。
2. 直接插入排序
   
   在代码实现中，预排序其实就是gap>1时进行排序的过程，直接插入排序也就是gap==1时的排序过程。
   完整代码如下：

void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		//也可以gap /= 2;
		gap = gap / 3 + 1;//除2可以保证最后一次是1，除3不行所以要加1

		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[i + gap];
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

希尔排序是对直接插入排序的优化，但是其具体效率很难计算。
我们暂且认为时间复杂度大约在O(N^1.3)，慢于O(NlogN)。

另外很容易发现，在预排序分组插排的过程中，相等元素的相对次序可能会发生变化，所以希尔排序是不稳定的。

四、直接选择排序

直接选择排序的思想其实非常简单，以升序为例，就是每次选出最小的换到左边或者最大的换到右边。

很容易发现，直接选择排序的效率较低，所以我们在代码实现的时候采用一次遍历同时找到最大、最小换到右边、左边的方案。
完整代码如下：

void SelectSort(int* a, int n)
{
	int left = 0, right = n - 1;

	while (left < right)
	{
		//选出最小的和最大的，得到下标
		int mini = left, maxi = left;
		for (int i = left + 1; i <= right; i++)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}

		//最小放左边，最大放右边
		swap(&a[left], &a[mini]);
		
		//如果left和maxi重叠，交换后修正一下
		if (left == maxi)
		{
			maxi = mini;
		}
		swap(&a[right], &a[maxi]);

		left++;
		right--;
	}
}

不难看出，直接选择排序的时间复杂度最好最坏都是O(N^2)，效率较低，所以实际中很少使用直接选择排序。
另外也很容易看出，直接选择排序的空间复杂度是O(1)。

而且，由于每次遍历存在交换到最左边或者最右边的过程，所以排序之后相等元素的相对次序可能会发生变化。
因此，直接选择排序是不稳定的。

上文提到，直接选择排序的效率不高，所以很少使用。
事实上，如果改用堆的结构来选择数据，情况就会不一样。

五、堆排序

堆排序是选择排序的一种，通过堆来进行选择数据。
需要注意的是：排升序要建大堆，排降序建小堆。
具体过程如下：

完整代码如下：

void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		// 选出左右孩子中大的那一个
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++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)
{
	// 建堆 -- 向下调整建堆 -- O(N)
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}

	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[end], &a[0]);
		AdjustDown(a, end, 0);

		--end;
	}
}

堆排序的时间复杂度是O(NlogN)，相比直接选择排序就快了很多。
空间复杂度依然是O(1)。
观察堆排序的过程，显然，堆排序不具有稳定性。

六、冒泡排序

冒泡排序我们都很熟悉了，就是每趟都比较相邻两个元素大小，如果不满足升序或降序则交换位置，总共比较n-1趟。
这里直接上动图和代码，相信大家都很容易能理解。

void BubbleSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)// n-1 趟
	{
		bool exchange = false;//检查是否交换
		for (int j = 0; j < n - 1 - i; j++)// 每趟比较 n-1-i 次
		{
			if (a[j] > a[j + 1])
			{
				swap(&a[j], &a[j + 1]);
				exchange = true;
			}
		}

		if (exchange == false)//如果没交换，说明已经有序
		{
			break;
		}
	}
	//时间复杂度
	//最坏：O(N^2)
	//最好：O(N)
	//空间复杂度：O(1)
}

由于两两元素比较的时候，相等的话不会交换位置，所以相等元素的相对次序不变，因而冒泡排序具有稳定性。

我们可以发现，冒泡排序的时间复杂度无论最坏情况还是最好情况，都和直接插入排序相同。
因此我们可以比较一下二者的效率。

七、冒泡排序与直接插入排序效率对比

数组有序时：一样
接近有序时：冒泡稍慢一些
数组局部有序：冒泡慢很多

所以，虽然冒泡排序可能是我们接触最早的一种排序方法，但是它的效率真的很一般，甚至不如直接插入排序。