数据结构初阶·排序算法(内排序)

前言：

1 冒泡排序

2 选择排序

3 插入排序

4 希尔排序

5 快速排序

5.1 Hoare版本

5.2 挖坑法

5.3 前后指针法

5.4 非递归快排

6 归并排序

6.1递归版本归并

6.2 非递归版本归并

7 计数排序

8 排序总结

前言：

目前常见的排序算法有9种，冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，计数排序，基数排序，桶排序。实际生活中排序的应用也是有限的，今天我们介绍其中7个，基数排序和桶排序不介绍。介绍常用的即可。

顺带一嘴，本文里面所有的排序都是内排序，也就是在内存里面进行排序的，还有一种排序叫做外排序，即是在磁盘里面进行排序的，这种排序具有记忆性，外排序用到的就是归并排序，因为归并排序有一个特点就是空间复杂度为O(N)。

好了正文开始。

1 冒泡排序

这个排序是排序中的老大哥了，不是说效率有多高，是因为一开始接触排序的同学绝对逃不开它哈哈。

冒泡排序的思想是两两比较，从而达到冒泡一趟可以确定一个数的位置，所以一趟下来需要的操作有两两比较，一趟就需要遍历整个数组，所以想要确定数组中所有元素的位置就需要两个循环，一个循环用来控制趟数，一趟循环用来控制两两比较。

我们排升序，一旦两两相邻的数满足条件，就交换两个变量的位置，基本思想确定了，现在来实现基本代码：

int arr[] = { 5,3,1,4,6,8,2,9,0,7 };
//冒泡排序
for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
{for (int j = 0; j < sizeof(arr) / sizeof(int) - 1; j++){if (arr[j] > arr[j + 1]){swap(arr[j], arr[j + 1]);}}
}

这就是最最基本的代码了，注意，这里的j < sizeof(arr) / sizeof(int) - 1的减一是一定要的，因为不减一是可能越界的，比如最后一个数不用冒泡了，但是没有减一就又冒了过去， + 1之后一下就越界了。

那么，我们在此基础上面如何进行修改呢？

我们知道，冒泡一趟可以确定一个数的位置，如果要排序10个数的位置，那么有没有必要冒泡10趟？没有吧，因为确定了9个数的位置最后一个数的位置自然而然就确定了，所以趟数可以进行修改，再来看第二个循环，一趟下来就确定了一个数的位置，那么最后1个或者n个数就不用冒泡了，因为我们知道它是已经排序好了的，那么一趟排好一个，我们就可以少冒泡一个，所以可以利用i进行循环次数的减少。

	for (int i = 0; i < sizeof(arr) / sizeof(int) - 1; i++){for (int j = 0; j < sizeof(arr) / sizeof(int) - i - 1; j++){if (arr[j] > arr[j + 1]){swap(arr[j], arr[j + 1]);}}}

那么我们还有没有修正空间呢？

有的，如果我们排序一个升序数组，但是该数组本身就是一个升序的数组，我们冒泡完一趟发现所有数都满足升序，就不想走后面的怎么办？这个时候我们就应该使用标志来确定一趟有没有交换，如果一趟没有交换，我们也就没有必要冒泡下去了：

	for (int i = 0; i < sizeof(arr) / sizeof(int) - 1; i++){int flag = 0;for (int j = 0; j < sizeof(arr) / sizeof(int) - i - 1; j++){if (arr[j] > arr[j + 1]){swap(arr[j], arr[j + 1]);flag = 1;}}if (0 == flag)break;}

这才是冒泡的最终形态，那么简单分析一下：
循环次数是一个标准的等差数列，所以时间复杂度为O(N^2)；

空间复杂度方面，是没有新开空间的，所以空间复杂度为O(1)。

2 选择排序

选择排序顾名思义，通过选择来进行排序，我们选择的是最大最小值，再选择次大次小值，给他们安放到正确的位置上，从而完成排序：

这是选择排序的动图，是选择的最小值，但是我们今天实现的比这个高级一点点，我们今天实现的是双向选择，同时选择最大的和最小的，相对上面的来说并没有难度的增加，无非是代码加了一点而已。

选择排序的总体思想就是两边缩短，从现有的可访问区间里面选择最值，那么我们就需要控制区间，剩下的就是交换和选择最值了：

void SelectSort(int* arr,size_t size)
{int begin = 0, end = size - 1;while (begin  <  end){int mini = begin;int maxi = begin;//选择排序选择是区间 ->循环条件是区间for (int i = begin + 1; i <= end; i++){//找到最小的 记录下标if (arr[i] < arr[mini]){mini = i;}//找到最大的 记录下标if (arr[i] > arr[maxi]){maxi = i;}}swap(arr[begin], arr[mini]);//当max的值在最前面的时候 ->交换前已经冲突if (maxi == begin)maxi = mini;swap(arr[end], arr[maxi]);begin++, end--;}
}

这里的begin和end是左闭右闭区间，所以在循环控制的时候就需要注意是i <= end，同时，我们相当于是在1 到下标为size - 1的数据，这里要是想要用i = begin开始遍历也可以，无非就是加了一条让自己和自己比较的语句，实际没必要，能减少循环次数咱们就减少。

那么有一个新问题，如果数组的最大值在数组下标为0的位置，那么最小元素就和最大值发生了交换，此时最大值的下标已经发生改变，我们再进行一轮的交换就不行，所以这里需要额外判断一下，防止maxi的值交换前变化。

时间复杂度方面，是一个标准的等差数列，也就是O(N^2)，空间复杂度方面，没有多开空间，所以是O(1)。

3 插入排序

如果所示，是插入排序的动态演示。

单趟来看，就是把第n个数看成要插入的数据，再分别是前n - 1个数据进行比较，如果满足插入条件，就插入到相应位置，这里就需要一个临时变量来存储插入的数据，并且存在数据覆盖，那么整体来看，就是插入一个数据，把该数据之前的所有数据看成是有序的，即我们应该从前两个数据开始操作。

int end;
int tmp = arr[end + 1];
while (end >= 0)
{if (arr[end] > tmp){arr[end + 1] = arr[end];end--;}else{break;}
}
arr[end + 1] = tmp;

这就是一个单趟，end + 1为插入数据，前end个数据都是要比较的元素，end >= 0也是因为下标为0的元素也需要比较。

那么插入排序就可以理解为，排序 [0,1]，[0,2],[0,3]……[0,size- 1]区间，所以还需要一个循环用来控制end，好保证是区间一个一个排号的：

for (int i = 0; i < size - 1; i++)
{int end = i;int tmp = arr[end + 1];while (end >= 0){if (arr[end] > tmp){arr[end + 1] = arr[end];end--;}else{break;}}arr[end + 1] = tmp;
}

这就是一个标准的插入排序，这个排序理解好之后，希尔排序才好理解，因为希尔就是在该排序的基础上进行修正的。

那么这个的时间复杂度和空间复杂度都很标准，是O(N^2),O(1)。

4 希尔排序

可以看到这里的动图和之前的动图有着不一样的点，即颜色不同，这里的颜色不同代表的是分的组别不同，即希尔将不同的元素按照一定的gap（间隔）分成了不同的组，那么问题来了，为什么要在插入排序的基础上加上分组这个思想呢？

原因是插入排序的最不理想的时候就是完全倒序的时候，这个时候基本上把循环吃满了，所以希尔就想，能不能先预排序一下，把所有的元素尽量的靠近最终的位置，所以分组排序，是一个预排序的过程，让数据尽量接近正确位置，预排序我们需要用到gap，即间隔，我们将间隔了gap的数据分为同一组，这一组数据里面进行排序，gap在排序的过程也在不断变化，那么为什么要变化呢？

这样想，gap = 1就是插入排序，就会好理解很多了。

所以现在我们要解决的第一个问题是，如何预排序，假设gap = 4，我们联想插入排序的时候，是gap = 1的排，那么现在无非就是间隔大了一点，所以只需略加修改:

int gap = 4;
int end = 0;
int tmp = arr[end + gap];
while (end >= 0)
{if (arr[end] > tmp){arr[end + gap] = arr[end];end -= gap;}else{break;}
}
arr[end + gap] = tmp;

这是预排序了一组，现在就是，加循环，使每个组都预排序了，整个预排序就算是完成了：

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

这是最原始版本的预排序，是不是三层循环看着头都大了？最外层循环用来控制排序哪一组的，第二层循环，用来控制数组中该组的所有数据，内层就是进行排序，这种排序就太老实了，看着头大。

现在不难发现，gap不止是间隔，gap实际上是把所有的数据分为多少组，反正都是组内部相互排序了，我们每个组同时排不可以吗？

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

画一下图的话就会发现相当于是每个大区间的小区间依次排序，这样看着就不乱，那么预排序现在就做好了，我们现在就是考虑怎么从预排序变成最终排序？

那就很简单了，gap等于1就是最终排序，但是我们的gap也不能等于0，而且这个gap说法有挺多的，最后大部分结论是三等分数组，但是为了gap不能等于0，就会除3之后 + 1，只要让gap最终走到1但是不为0就可以：

int gap = size;
while (gap > 1)
{gap = gap / 3 + 1;for (int i = 0; i < size - gap; i++){int end = i;int tmp = arr[end + gap];while (end >= 0){if (arr[end] > tmp){arr[end + gap] = arr[end];end -= gap;}else{break;}}arr[end + gap] = tmp;}
}

最终版本如上。

关于时间复杂度是很难计算的，主要是因为gap，这里就记住结论，O(N^1.3)，空间复杂度是O(1)。

5 堆排序

堆排序就是老生常谈的知识了，因为向上建堆的时间复杂度是O(N * logN)，向下建堆的时间复杂度是O(N - logN)即O(N)，我们就采用向下建堆，最后呢，调整一下就没问题了，先来向下调整算法：

void AdjustDown(int* a, int size, int parent)
{int child = parent * 2 + 1;while (child < size){if (child + 1 < size && a[child + 1] > a[child]){++child;}if (a[child] > a[parent]){swap(a[child], a[parent]);parent = child;child = parent * 2 + 1;}else{break;}}
}

然后开始建堆，建堆的思想很简单，如果每个堆都是很大堆，那么整个堆就是大堆了，所以我们从最后一个父节点开始调整，就有(size - 1 - 1 / 2)来找第一个父节点，随机调整每一个父节点：

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;
}

时间复杂度标准的O(N * logN)，空间复杂度为O(1);

6 快速排序

快速排序最初是由hoare发明的，简称为快排，既然敢叫快排就有它的厉害之处，快排的整体思想是将一个数一趟放到正确的位置，简单来说就是一趟下来，该数左边的数一定小于它，右边的数一定大于它，这里我们看个动图：

好吧没找到哈哈哈

那我描述一下，hoare版本是将左边第一个数据，即下标为0的元素选为key，然后有两个“东东”分别从首元素和末尾元素出发，因为我们排的是升序，所以精髓是在于右边的小东东先走，左东东找大，右东东找大小，直到右边的找到了比key小的就停下来，左边同理，找到比key大的就停下来，当两个都找到了，ok进行一次交换，这样相当于把一大一小换位，最后左右东东相遇的时候，就是key的正确位置，因为左右东东已经交换了来的路上的所有比key大的和比key小的，这样一趟下来，key的位置就是正确位置。

一趟下来我们就能确定一个数的正确位置，此时，数组被分为了三段，[begin,key - 1] key [key + 1,end]，如果我们对最右边的区间在走一个单趟，还是会被分为三个区间，所以这里我们要用到的还有递归，遍历了根之后，然后遍历左子树右子树(二叉树乱入)，这里就和二叉树挺像的了，这里其实就是前序遍历了。那么现在就来实现一下hoare版本吧。

6.1 Hoare版本

void QuickS(int* arr,int begin,int end)
{if (begin >= end)return;int keyi = begin;int left = begin, right = end;while (left < right){//右边找小while (left < right && arr[right] >= arr[keyi]){right--;}//左边找大while (left < right && arr[left] <= arr[keyi]){left++;}swap(arr[right], arr[left]);}swap(arr[keyi], arr[left]);keyi = left;QuickS(arr, begin, keyi - 1);QuickS(arr, keyi + 1, end);}

霍尔版本就需要三个参数，因为我们对区间不停的排序，所以是arr,begin,end，然后对于为什么要赋值给left 和 right呢？因为最后的递归调用需要用到原来的begin和end，所以这里需要临时变量存储一下，当然有其他的存储方法，都是可以的。

然后是循环条件，最外while循环的循环条件没什么好说的，里层的while的循环条件是比较容易忘记的，因为里层的while循环条件也是要有left < left的，如果没有，那么一旦找不到就会死命的找，就会导致left > right的情况，其次，>= <= 的等于也是必要的，如果没有等于，left right 就会停在那里，导致原来要找的小的或者大的没有找到。

找到进行两次交换，最后就是两次区间递归，这里只要保证区间是对的，变量怎么取都可以，只要保证的是递归的那两个区间就行。

那么这里，提问为什么一定要右边先走？

因为要保证最后和arr[keyi]交换的位置是比keyi小的。

为什么右边相遇的位置一定是比arr[keyi]小的？

是因为右边先走，右边先走有两种相遇情况。
第一种是R遇见L，R没有找到小的，一直往L走，在此之前可能是R L都动过，所以L此时下面是一个比keyi小的数，相遇一定是比keyi小的，也可能是L没动过，那么R就可能是一直找到keyi自己，也是一种正确的情况。

第二种是L遇见R，R已经找到了小的，所以此时L遇见了R也肯定是遇见了一个比arr[keyi]小的数。

以上是快排的大部分易错点，后面的三个版本都是在单趟的基础上进行优化，我们就将单趟实现的不同函数分别写，最后调用函数，再递归，如下:

int PartSort1(int* arr, int begin, int end)
{//三数取中int midi = GetMidi(arr, begin, end);swap(arr[begin], arr[midi]);int left = begin, right = end;int key = begin;while (left < right){//右边找小while (arr[right] >= arr[key] && left < right){right--;}//左边找大while (arr[left] <= arr[key] && left < right){left++;}swap(arr[left], arr[right]);}swap(arr[left], arr[key]);return left;
}
void QuickSort(int* arr, int begin, int end)
{if (begin >= end)return;int key = PartSort1(arr, begin, end);QuickSort(arr, begin, key - 1);QuickSort(arr, key + 1, end);}

这里可能还有一个疑问就是为什么keyi一定要取左边的，我取右边的不行吗？取两边都是可以的，取中间也可以，但是中间就麻烦一点，有的时候固执的取左边效率就比较低下，比如倒序的情况，这里的话我们就需要三数取中，也就是在左右中三个数取中间值的数来当keyi，这样好点，就和希尔的预排一样，有点类似，希尔是把数提前接近，这里是选择一个不用执行那么多语句的数来当keyi。三数取中就比较就可以了：

int GetMidi(int* a, int begin, int end)
{int midi = (begin + end) / 2;// begin midi end 三个数选中位数if (a[begin] < a[midi]){if (a[midi] < a[end])return midi;else if (a[begin] > a[end])return begin;elsereturn end;}else // a[begin] > a[midi]{if (a[midi] > a[end])return midi;else if (a[begin] < a[end])return begin;elsereturn end;}
}

但是但是，现在还有一个小问题就是，有的时候也存在杀鸡用牛刀的情况，比如我要对10000个数进行快排，剩余最后几个数的时候，我还是要一个个的去走递归，那就太麻烦了，我还不如选一个排序来完成接下来的排序呢，比如7个数我要递归7次，还是有点麻烦的，所以有的时候会这样：

//小区间优化版本 
void QuickSort1(int* arr, int begin, int end)
{if (begin >= end)return;if (end - begin + 1 <= 10){//+begin是必要的InsertSort(arr + begin, end - begin + 1);}else{int midi = GetMidi(arr, begin, end);swap(arr[begin], arr[midi]);int left = begin, right = end;int key = begin;while (left < right){//右边找小while (arr[right] >= arr[key] && left < right){right--;}//左边找大while (arr[left] <= arr[key] && left < right){left++;}swap(arr[left], arr[right]);}swap(arr[left], arr[key]);QuickSort(arr, begin, left - 1);QuickSort(arr, left + 1, end);}
}

还有10个数的时候我们调用其他排序，虽然但是效率提高了一点点，但是没有太多，所以我们了解一下就行。

6.2 挖坑法

接下来就是挖坑的介绍了，我们要先记住一个点就是，单趟快排的基本点就是让一个数到它正确的位置，那么怎么到正确的位置呢？即让左边的数小于它，右边的数大于它就行。基本思想是不变的。

挖坑的具体做法是这样的，将arr[keyi]存放到一个临时变量里面去，此时第一个坑位形成，即是arr[keyi]，然后同样的，右边开始找小的，找到了，该数据给坑位，此时右边找到的位置就是一个坑位，左边同理，找到一个大的，给值，变坑位，最后左右相遇，就是keyi的正确位置了。

代码如下：

int PartSort2(int* arr, int begin, int end)
{//三数取中int midi = GetMidi(arr, begin, end);swap(arr[begin], arr[midi]);int key = arr[begin];int hole = begin;while (begin < end){//等于是必要的while (arr[end] >= key && begin < end){end--;}arr[hole] = arr[end];hole = end;while (arr[begin] <= key && begin < end){begin++;}arr[hole] = arr[begin];hole = begin;}arr[hole] = key;return hole;
}

挖坑相对hoare版本的要理解多，但是总体思想是不变的。

6.3 前后指针法

前后指针的单趟思想也是没有变的，还是让一个数到它的正确位置上，不过这个到的过程可能有点差异而已，前后指针利用的是两个指针，指针prev最开始指向数组首元素，指针cur指向的是首元素的下一个位置，整个过程是，cur先走，判断该位置是否小于arr[keyi]，小于的话，prev就跟上来，如果是大于的话，那么prev就在原地不动，当cur指向的位置再次小于arr[keyi]，并且prev和cur之间隔着几个大的元素的时候，那么++prev之后交换cur指向的那个位置，重复这个过程即可，因为prev指向的就是比arr[keyi]小的位置，cur指向的是大的位置，交换则是为了最后正确位置做铺垫，最后的情况就是，prev和cur间隔的所有元素都比arr[keyi]大，此时prev的位置就是正确位置，交换prev的位置和arr[keyi]的位置即可完成一次单趟。

代码如下：

int QuickS(int* arr, int begin, int end)
{//三数取中int midi = GetMidi(arr, begin, end);swap(arr[begin], arr[midi]);int keyi = begin, prev = begin, cur = prev + 1;while (cur <= end){if (arr[cur] < arr[keyi] && ++prev != cur)swap(arr[prev], arr[cur]);cur++;}swap(arr[keyi], arr[prev]);return prev;
}

第一步肯定是三数取中，然后是选定三个下标，分别是keyi,prev,cur，因为begin - end是左闭右闭区间，所以循环结束条件是cur <= end，判断条件这里可能看着有点复杂，第一个是判断是否小于arr[keyi]，如果满足，那么++prev之后，不等于cur，就可以进行交换了，最后cur++，这里如果++prev != cur放在前面就不可以了，破坏了先决条件 arr[cur] < arr[keyi]，所以顺序也是要注意的，最后就是交换，返回对应下标了。

6.4 非递归快排

前面使用递归快排的时候，不难发现递归的顺序是根，左子树，右子树，那么我们非递归快排的时候实现的也是这种顺序模式，但是我们不能用递归，就需要利用到其他数据结构了，这里呢用到的是栈，即我们将区间段存进去，排序好之后再返回一些区间段，反复该操作，那么我们该如果排序呢？前面已经封装好了单趟的排序，所以我们可以直接复用即可，这也是为什么要封装单趟排序。

对于栈的使用，我们只需要记住，不停进栈，出栈即可，所以整个排序模式下来就是：

进栈，出栈，排序，返回区间段，就可以了，代码如下：

void QuickNR(int* arr, int begin, int end)
{//栈不是用来存储数据的 存储的是区间stack<int> s;s.push(end);s.push(begin);while (!s.empty()){int left = s.top();s.pop();int right = s.top();s.pop();int keyi = QuickS(arr, left, right);if (left < keyi - 1){s.push(keyi - 1);s.push(left);}if (right > keyi + 1){s.push(keyi + 1);s.push(right);}}
}

当栈为空的时候，也就是没有区间可以排序了，即所有区间都有序了，此时排序就完成了，先压begin还是end都是可以的，无非就是循环的top的顺序需要改一下。

快排的时间复杂度是O(N * logN)，空间复杂度为O(logN)；

7 归并排序

7.1递归版本归并

在前面介绍树的时候，介绍到过一道题，求总共的节点个数，具体做法就是整体二叉树看作是一个一个小的二叉树，从最低层的二叉树慢慢的归并上来，归并排序的思想和树的思想是一样的，我们不是要排序吗？那么我们排一个数的序，排序好了再排两个数的序，然后再是4个数排序，然后是8个数的排序，直到排完即可。

所以归并排序这里也是要用到递归的，递归到一个数的时候，就可以返回开始排序了，排序的时候我们是这样排的，两个数组成的集合已经有序，那么我们就两两比较，谁小谁就尾插即可，难就是难在如何递归上面：

void Merges(int* arr,int begin, int end, int* tmp)
{if (begin >= end)return;//递归int mid = (begin + end) / 2;Merges(arr, begin, mid, tmp);Merges(arr, mid + 1, end, tmp);//归并int begin1 = begin, end1 = mid;int begin2 = mid + 1, end2 = end;int i = begin;while (begin1 <= end1 && begin2 <= end2){if (arr[begin1] <= arr[begin2]){tmp[i++] = arr[begin1++];}else{tmp[i++] = arr[begin2++];}}while (begin1 <= end1){tmp[i++] = arr[begin1++];}while (begin2 <= end2){tmp[i++] = arr[begin2++];}memcpy(arr + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}

void MergeS(int* arr, int size)
{int* tmp = new int[size];Merges(arr,0,size - 1,tmp);delete[] tmp;
}

这里因为tmp的原因所以加了一个函数，当然也可以都写在一个函数里面，但是不太好控制，这里建议的就是分别写在两个函数。

归并的时间复杂度是O(N * logN)，空间复杂度是O(N)。

7.2 非递归版本归并

同样，归并也有非递归版本，也就是左子树右子树，根，递归那里，是从1 -> 2 -> 4 -> 8这样排序好的，也就是说我们非递归就是要直接实现这个过程，所以我们需要一个变量用来计算我们一次性要排序多少组，这里用到了gap，那么数组里面的每个gap组拍好了之后，gap就应该*2，重复这个过程就可以，那么越界的问题我们应该如何处理？

越界嘛，无非就是begin1 end1 begin2 end2出现了问题，那么如果是begin2 和 end1出现了问题直接break就可以了，因为已经排序完成，end2出现问题我们进行修正就可以了，begin1出问题?那基本不会的，所以，代码如下：

void MergeSortNonR(int* arr, int n)
{int* tmp = new int[sizeof(int) * n] {0};int gap = 1;while (gap < n){//整体排序 排序好了gap改变，模仿 1 -> 2 -> 4 -> 8for (size_t i = 0; i < n; i += 2 * gap){int begin1 = i, end1 = i + gap - 1;int begin2 = i + gap, end2 = i + 2 * gap - 1;//排序完成if (end1 >= n || begin2 >= n){break;}//后面部分差点意思if (end2 >= n){end2 = n - 1;}//开始归并int j = begin1;while (begin1 <= end1 && begin2 <= end2){if (arr[begin1] < arr[begin2]){tmp[j++] = arr[begin1++];}else{tmp[j++] = arr[begin2++];}}while (begin1 <= end1){tmp[j++] = arr[begin1++];}while (begin2 <= end2){tmp[j++] = arr[begin2++];}memcpy(arr + i, tmp + i, sizeof(int) * (end2 - i + 1));}gap *= 2;}delete[] tmp;
}

8 计数排序

计数排序是很特殊的，因为它不是比较排序，往往排序的思想都是，比较谁大谁小再决定怎么操作，它不一样，它是通过数组的下标来排序的，计数排序的具体操作是先开空间，空间开多大呢？空间大小是排序的数集合的最大值减去最小值，所以排序有一个操作就是要找最大值最小值，其次就是，为什么要开这么大的空间？我只要最大的不行吗？也可以，但是空间浪费是很大的，比如排序 11101 99999，就会浪费10000多个空间，所以这里用到了相对映射。

空间开好了之后，就是用下标，判断每个下标对应的数字有多少，此时最小值就用上了，++之后，判断count下标对应的数字有多少，就赋值就行了。如下：

void Countsort(int* arr, int size)
{int max = arr[0];int min = arr[0];//找最值for (int i = 0; i < size; i++){if (arr[max] < arr[i])arr[max] = arr[i];if (arr[min] > arr[i])arr[min] = arr[i];}int* count = new int[(max - min + 1) * sizeof(int)] {0};for (int i = 0; i < size; i++){count[arr[i] - min]++;}int j = 0;for (int i = 0; i < max - min + 1; i++){while (count[i]--){arr[j++] = i + min;}}delete[] count;
}

时间复杂度为O(N),空间复杂度为O(N)，效率高得离谱。