---

一、八大排序剖析链接

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

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

二、排序的稳定性

在未排序的数据中，有多个相同数据，若经过排序后，相对顺序保持不变。
未排序，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个数，排序就完成了

代码：

// hoare（左右指针法)
void QuickSort(int* a, int begin, int end)
{
	// 结束条件：区间不存在或只有一个数，该情况是有序的
	if (begin >= end)
		return;

	int left = begin, right = end;
	int keyi = left;
	
	// 相遇就结束
	while (left < right)
	{
		// 右区间找比key小的数
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}

		// 左区间找比key大的数
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}

		// 交换
		Swap(&a[left], &a[right]);
	}
	// 此时begin和end在同一位置，需要将其中key和其中一个交换
	Swap(&a[left], &a[keyi]);
	keyi = left;	// 更新keyi的位置

	// [begin, keyi-1] keyi [keyi+1, end]
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

3.4.2 挖坑法

1. 记录key，key一般都是最左边，目的就是为了把key排到正确的位置，同时将key设为坑位
2. 开始坑在左边，右边开始找值补坑，right找到比key小的值，放入坑位，right形成新的坑
3. 现在坑在右边，左边开始找值补坑，left找到比key大的值，放入坑位，left形成新的坑
4. 直到left和right相遇就结束，最后把key放到坑位，key就排到正确的位置
5. 以排好的key（下标为pivot）开始左右分区，[begin, pivot - 1] pivot [pivot + 1, end]，进行分治递归

代码：

void QuickSort_pivot(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int left = begin, right = end;
	int key = a[left];
	int pivot = left;
	
	while (left < right)
	{
		// 找小于key的数
		while (left < right && a[right] >= key)
		{
			right--;
		}
		// 找到小的数放到左边的坑里，自己形成新的坑位
		a[pivot] = a[right];
		pivot = right;
		
		// 找大于key的数
		while (left < right && a[left] <= key)
		{
			left++;
		}
		// 找到大的数放到右边的坑里，自己形成新的坑位
		a[pivot] = a[left];
		pivot = left;
	}
	// 最后pivot会指向相遇点，相遇点就是key排好的位置
	a[pivot] = key;	

	// [begin, pivot-1] pivot [pivot+1, end]
	QuickSort_pivot(a, begin, pivot - 1);
	QuickSort_pivot(a, pivot + 1, end);
}

3.4.3 前后指针法

实现思路：

1. 记录key，key一般都是最左边，目的就是为了把key排到正确的位置。
2. prev记录begin的位置，cur记录begin+1的位置，cur一直递增的 ，如果cur处的值小于key的值，prev++，然后prev处的值和cur处的值交换（因为prev++后可能会相遇cur，这是原地交换没有意义，所以prev++ !=cur才交换），直到cur越界就停止
3. cur越界后，说明prev的位置就是key排好的位置，所以key和cur处的值交换后，key就排到正确的位置，开始keyi在最左边，需要更新keyi的位置
4. 以排好的key开始左右分区，[begin, keyi - 1] keyi [keyi + 1, end]，进行分治递归

需要注意排序的思想两指针间隔，间隔的数都是大于key，当cur遇到小的数，prev++就会在间隔的地方（大于key的数位置），然后交换，就是大的数往后抛，小的数往前抛。

代码：

void QuickSort_pointer(int* a, int begin, int end)
{
	if (begin >= end)
		return;
	
	int keyi = begin;
	int prev = begin, cur = begin + 1;

	while (cur <= end)
	{	
		// cur一直递增，碰到小于key的值并且prev++不等于自己，就交换
		// prev++ == cur，会原地交换
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		
		cur++;
	}
	// key交换到排好的位置，同时更新keyi的位置，原先在最左边
	Swap(&a[keyi], &a[prev]);
	keyi = prev;	

	// [begin, keyi-1] keyi [keyi+1, end]，进行分治
	QuickSort_pointer(a, begin, keyi - 1);
	QuickSort_pointer(a, keyi + 1, end);
}

3.4.4 三数取中优化

该优化是针对快排的最坏情况（有序情况），确保在每次在分区里选key的时候，能保证在分区内不会取最或最大的数。
三数取中：最左边和最右边以及中间的数，取这三个数中，值的大小是中间的（不是三个数里最大或最小），比如在有序的情况下中间的值真好能二分区间。

代码如下：

// 三数取中
int GetMidIndex(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
			return mid;
		else if (a[left] < a[right])
			return right;
		else
			return left;
	}
	else	
	{	// a[left] >= a[mid]
		if (a[mid] > a[right])
			return mid;
		else if (a[right] < a[left])
			return right;
		else
			return left;
	}
}

3.4.5 小区间优化

众所周知，与递归相关的算法，递归的过程类似与二叉树结构，高度是h，一共有$2^h-1$个节点，调用就有$2^h-1$次，递归到最后几层数据已经接近有序并且调用次数占了大部分（最后一层节点有$2^{h-1}$个，每一节点都需要调用，这将近占用一半的调用次数）。所以小区间优化的目的是减少递归调用的次数。

挖坑法加上三数取中和小区间优化代码如下：

void QuickSort_pivot(int* a, int begin, int end)
{
	if (begin >= end)
		return;
	
	// begin和end是闭区间，如[0,9]，一共10个数，所以+1，10个数以下就小区间优化
	if (end - begin + 1 > 10)
	{
		// 三数取中优化
		int midIndex = GetMidIndex(a, begin, end);
		Swap(&a[begin], &a[midIndex]);
	
		int left = begin, right = end;
		int key = a[left];
	
		int pivot = left;
		
		
		// 挖坑法
		while (left < right)
		{
			while (left < right && a[right] >= key)
			{
				right--;
			}
			a[pivot] = a[right];
			pivot = right;
	
			while (left < right && a[left] <= key)
			{
				left++;
			}
			a[pivot] = a[left];
			pivot = left;
		}
		a[pivot] = key;
	else
	{
		// 小区间优化
		InsertSort(a + begin, end - begin + 1);
	}
}

3.4.6 快排非递归版

思路：

1. 先入右下标，在左下标，因为可以先取到左下标
2. 取左右下标组成一个区间，单趟排好一个值（key），在利用key分成左区间[left，key-1]，右区间[key+1，right]。
3. 检查左右区间数据个数，如果区间个数有二个以上，就需要在入栈排序
4. 重复2,3步，直到栈为空，数据就都排好了，由于栈的特性，永远左区间先取出，所以先排好，右区间在排好，在过程上就和递归调用一样。

代码如下：

// 快排单趟前后指针法
int SingleQuickSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int keyi = begin;
	int prev = begin, cur = begin + 1;

	while (cur <= end)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		cur++;
	}
	Swap(&a[keyi], &a[prev]);
	keyi = prev;

	return keyi;
}

void TestQuickSortNonR(int* a, int n)
{
	Stack st;
	StackInit(&st);

	// 先入右，再入左，为了先取左
	StackPush(&st, n - 1);	
	StackPush(&st, 0);

	// 栈为空，排序就完成
	while (!StackEmpty(&st))
	{
		int left = StackTop(&st);
		StackPop(&st);
		int right = StackTop(&st);
		StackPop(&st);

		// 快排单趟，排好一个值key，分割左右区间
		int keyi = SingleQuickSort(a, left, right);
		// [left, keyi - 1] keyi [ keyi + 1, right]

		// key+1小于right，说明至少右区间还有两个数据，还需要入栈排序
		if (keyi + 1 < right)
		{
			//先入右，再入左
			StackPush(&st, right);
			StackPush(&st, keyi + 1);
		}
		
		// left小于keyi - 1，说明至少左区间还有两个数据，还需要入栈排序
		if (left < keyi - 1)
		{
			//先入右，再入左，组成左区间
			StackPush(&st, keyi - 1);
			StackPush(&st, left);
		}
	}
	StackDestroy(&st);
}

3.5 归并排序

3.5.1 递归版

思路：

• 前提：
  申请一个临时数组tmp，因为我们不能在原数组归并，不然会造成覆盖，需要在临时归并，在拷回原数组里。
  由于创建了临时数组，我们就需要在创建一个子函数用来专门递归，不然每次调用都会申请空间

• 子函数思路：

1. 将序列从中间分成两个区间[left，mid] [mid + 1，right]，调用递归，直到只剩一个数据，一个数据就表示有序了。
2. 在把递归的两个区间进行合并，begin1和end2表示左序列，begin1和end2表示右序列，比较两个序列的值插入到临时数组里，其中肯定会有一个先结束，当其中一个序列拷贝完了就停止拷贝。
3. 把剩下未合并的数据，全部放到tmp数组里。
4. 最后在tmp数组的数据拷到原数组里。

// 子函数：用来递归
void _MergeSort(int* a, int left, int right, int* tmp)
{
	if (left >= right)
		return;
	
	int mid = (left + right) >> 1;

	// 分区[left, right] -> [left, mid] [mid + 1, right]
	_MergeSort(a, left, mid, tmp);
	_MergeSort(a, mid + 1, right, tmp);

	// 标识归并两个有序的开始和结束
	int begin1 = left, end1 = mid;
	int begin2 = mid + 1, end2 = right;
	
	// 两个序列合并，肯定会有一个先结束
	int index = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[index++] = a[begin1++];
		}
		else
		{
			tmp[index++] = a[begin2++];
		}
	}

	// 处理剩下未合并完的数据，合并完的肯定不会进入循环
	while (begin1 <= end1)
		tmp[index++] = a[begin1++];

	while (begin2 <= end2)
		tmp[index++] = a[begin2++];

	// tmp的数据拷贝到原数组，闭区间所以拷贝个数要加1
	memmove(a + left, tmp + left, (right-left+1) * sizeof(int));
}

void MergeSort(int* a, int n)
{
	// 创建临时数组，用来存放合并完的数据
	int* tmp = (int*)malloc(n * sizeof(int));
	_MergeSort(a, 0, n - 1, tmp);
	
	free(tmp);
}

3.5.2 非递归版

1. 同样也需要创建一个临时数组tmp，不能在原数据归并会覆盖。
2. gap为每组数据个数，先从gap为1，一次两组数据归并，模拟递归最后一层的归并，如：[0,0]和[1,1]归并
3. 通过每组个数(gap)推导出每组数据的区间，得出两组数据区间是[i，i + gap - 1]，[i + gap，i + 2*gap - 1]。
4. i需要加上2*gap，原来的区间已归并好了，所以需要指向下一次归并的起始位置，直到 i >= n结束，循环条件就要设为i < n，表示排好差距为gap的多组数据。
5. 排好差距为gap多组数据后，gap*2，下一趟需下一趟归并的一组数据个数翻倍，直到gap为gap >= n结束，>=就只有一个组数据，不能归并，循环条件就是gap < n，就是说把未排序的数据分成两组数据，两组数据归并完就排好了序。
6. 把临时数组的数据拷到原数组。

越界处理：

1. 右区间不存在，直接跳出循环break，不进行归并。
2. 右区间超过数据长度，进行修正，右区间结束标识n-1，就是最后一个数据的下标。
3. 由于右区间不存在直接跳出的情况，tmp数组就会有随机值情况，并且左区间在原数组中也是有序的。
   上面代码是把当前差距为gap的数据，全部归并好，在全部拷贝到原数据中。
   这里就要修改成归并了多少，就拷多少，归并完直接拷贝，需要放进循环里面。

void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(n * sizeof(int));
	assert(tmp);

	int gap = 1;	// 每组的数据个数
	
	// gap < n，就说明有两组数据才能归并，>=就说明只有一组数据
	while (gap < n)
	{
		for (int i = 0; i < n; i += gap * 2)
		{
			// [i, i + gap - 1] [i + gap, i + gap * 2 - 1]
			// 如：[0, 0] 和 [1, 1]......
			// 标识需归并两组数据的范围
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + gap * 2 - 1;

			// 右区间不存在
			if (begin2 >= n)
				break;

			// 右区间超过了数据长度，修正成数据的长度
			if (end2 >= n)
				end2 = n - 1;

			// 归并
			int index = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[index++] = a[begin1++];
				}
				else
				{	
					tmp[index++] = a[begin2++];
				}
			}

			// 剩余未归并完的数据全部放入tmp里
			while (begin1 <= end1)
			{
				tmp[index++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[index++] = a[begin2++];
			}

			// 拷贝数据，归并了多少，就拷多少
			for (int j = i; j <= end2; j++)
			{
				a[j] = tmp[j];
			}
		}
		gap *= 2;	// 下一趟归并的一组数据个数翻倍 
	}
}

3.6 选择排序

3.6.1 常规版（一次排好一个数）

实现思路：

1. 假设起始位置（i）是最小的，通过变量（minIndex）保存该下标
2. a[mini]从该下标（i）的下一个位置（i+1）开始去数据中依次比较
3. 找到比自己小的数据，就把mini设为小的下标，循环还没有结束，所以还会用mini位置的值去和后面的值比较。
4. 数据都比较完后，minIndex位置的值就是全部数据中最小的，如果minIndex不等于i（一开始i和minIndex的值一样，找到最小了的值后minIndex的会被改变），就需要交换两个位置的值，相等i的位置就是最小值，不用动。（加这个判断是防止数据是有序的，有序就没有必要交换）
5. i+1，为了把排好的数据给排除掉，i再去在找数据中最小的值，重复以上操作，直到i < n - 1结束。

注意：循环结束如果到i < n结束，在找数据时候就会越界如n = 1，i + 1就会越界，并且当已经排好了n-1个数后，最后一个元素已经是最大的元素，不需要再进行比较和交换操作了。

// 选择判断（常规版，选一个数）
void SelectSort(int* a, int n)
{
	// n-1个数排好了，最后一个数就是正确的位置，不用在排序
	for (int i = 0; i < n - 1; i++)
	{
		int minIndex = i;
		for (int j = i + 1; j < n; j++)
		{
			if (a[j] < a[minIndex])
			{
				minIndex = j;
			}
		}

		// minIndex改变了需要交换，minIndex的位置就是最小值
		// 没有改变，i的位置就是最小值，不用动
		if (i != minIndex)
		{
			Swap(&a[i], &a[minIndex]);
		}
	}
}

3.6.2 优化版（一次排好两个数）

实现思路：

1. begin和end标识数据的区间，注意是闭区间
2. 最小值（minIndex）从begin（最左边）开始放，最大值（maxIndex）从end（最右边）开始放。
3. 排好两个数据后，begin往后走，end往前走，排除已排好的数据（缩小区间），直到begin和end相遇就表示排好了。

// 选择判断（优化版，两个数）
void SelectSort_double(int* a, int n)
{
	int begin = 0, end = n - 1;
	while (begin < end)
	{
		// 一次选出最小值和最大值
		int minIndex = begin, maxIndex = end;
		for (int i = begin; i <= end; i++)
		{
			if (a[i] < a[minIndex])
			{
				minIndex = i;
			}

			if (a[i] > a[maxIndex])
			{
				maxIndex = i;
			}
		}

		if (minIndex != begin)
			Swap(&a[minIndex], &a[begin]);
		
		
		// max和begin重叠，maxIndex的值已被换到minIndex位置
		if (maxIndex == begin)
			maxIndex = minIndex;

		if (maxIndex != end)
			Swap(&a[maxIndex], &a[end]);

		begin++;
		end--;
	}
}

3.7 冒泡排序

实现思路：

1. 每次就排好一个数，第一个数据和第二数据先比较在交换，小的在前，大的在后，第二个数据在第三个数据交换，一直反复下去。a[j] > a[j + 1]
2. 该过程会把小数据（不是最小，只是相比下小数据）交换到前面，直到交换到最后一个数据，最大的数据就在最后面了（比他小的数据都交换在他前面了），为了防止后面数据都是有序，用一个变量标识下（交换了没有），如果后面数据有序继续比较和交换效率低，我们做一下判断，如果有序（没有交换），我们就可以直接跳出。
3. 排好一个数后，就排除已排好的数据（缩小区间），直到只剩最后一个数，j < n - 1 - i。
4. 一共只需要排n-1个数，和常规选择排序一个情况，n-1个数有序了，剩余的1个数肯定是有序的，就等于自己和自己比较在交换，无意义。

// 冒泡排序
void BubbleSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		// 标识是否交换，默认是没交换
		int exchange = 1;	
		for (int j = 0; j < n - 1 - i; j++)
		{
			if (a[j] > a[j + 1])
			{
				Swap(&a[j], &a[j + 1]);
				exchange = 0;	// 数据交换了
			}
		}
		
		// 数据没有交换，表示有序，就直接跳出
		if (exchange)
			break;
	}
}

3.8 计数排序

1. 计算出数据的范围区间，最大值减去最小值，这是相对范围min——max，绝对范围是0——max，太浪费空间。
2. 创建一个计数数组count，因为是闭区间，大小是max-min+1，用来存放数据出现的次数，初始化都是0。
3. 统计每个数出现的次数，放入到数据减去最小值的下标位置（计数数组的相对位置）。
4. 把数据写到原数组里，只写次数不为0的，出现了几次就写入几个数据，数据通过count的下标+最小值还原出来。

// 计数排序
void CountSort(int* a, int n)
{
	// 找到最小值和最大值
	int min = a[0], max = a[0];
	for (int i = 1; i < n; i++)
	{
		if (a[i] < min)
			min = a[i];

		if (a[i] > max)
			max = a[i];
	}

	// 计算出相对范围
	int range = max - min + 1;

	// 创建计数数组，初始化为全0
	// 方法1
	int* count = (int*)malloc(range * sizeof(int));	
	assert(count);
	memset(count, 0, range * sizeof(int));

	// 方法2，calloc申请的空间默认都是NULL或0（根据指针类型决定）
	//int* count = (int*)calloc(range * sizeof(int));	

	// 统计每个数出现的次数
	for (int i = 0; i < n; i++)
	{
		count[a[i] - min]++;
	}
	
	// 把数组写入原数组
	// 数据出现了多少次就写入多少个值
	int j = 0;
	for (int i = 0; i < range; i++)
	{
		while (count[i]--)
		{
			a[j++] = i + min;
		}
	}
}