void ShellSort(int* a, int n)		//希尔排序(缩小增量排序)
{int gap = n;while (gap > 1) //最后一次循环结束，gap等于1{gap = gap / 3 + 1;for (int i = 0; i < n - gap; i++)			//类比直接插入排序{int end = i;int tmp = a[i + gap];while (end >= 0)		//挪动{if (a[end] > tmp){a[end + gap] = a[end];end -= gap;}elsebreak;}a[end + gap] = tmp;			//挪完，插入}}}

void SelectSort(int* a, int n)
{int begin = 0;		//通常用下标记录数据，以便随机访问int end = n - 1;while (begin < end){int maxi = begin;		//每次都需要重建maxi 与 mini，需要封装在while内部	//不能初始化为 0 ，每次都要从begin处开始int mini = begin;for (int i = begin; i <= end; i++)		//再begin 和 end（包含end，是 <= ）这个区间查找{if (a[i] > a[maxi])maxi = i;if (a[i] < a[mini])mini = i;}Swap(&a[begin], &a[mini]);if (begin == maxi)		// == 不是 =maxi = mini;Swap(&a[end], &a[maxi]);begin++;end--;}
}

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是 通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

首先介绍什么是向下调整算法：

向下调整算法主要用于在删除堆的根节点或在根节点插入新值后，重新恢复堆的顺序性质。

向下调整算法的基本步骤如下：

1. 确定调整的位置：当删除或替换堆顶元素后，需要调整的节点通常是新的根节点。

2. 比较与子节点的值：在最小堆中，比较该节点与其子节点（如果存在）的值，确定哪个子节点的值最小；在最大堆中，则确定哪个子节点的值最大。

3. 交换：如果父节点的值大于（在最小堆中）或小于（在最大堆中）子节点的值，则与该子节点交换位置。

4. 重复：将交换后的子节点作为当前节点，重复步骤2和3，直到当前节点没有子节点，或者它的值已经符合堆的性质。

void AdjustDown(int* a, int n, int parent)			//升序建大堆，找大孩子
{int child = parent * 2 + 1;			//假设左孩子大while (child < n)		//child是下标，最后一次是 n - 1，可以参与调整{if (child + 1 < n&& a[child + 1] > a[child])child = child + 1;if (a[child] > a[parent]){Swap(&a[child], &a[parent]);parent = child;		//交换之后，不断迭代child = parent * 2 + 1;}else	//前提是，其余元素已经是个堆结构break;}}

在代码中，假设左孩子大，当右孩子存在时，若大于左孩子，则更新孩子的下标。

        if (a[child] > a[parent])
        {
            Swap(&a[child], &a[parent]);

            parent = child;        //交换之后，不断迭代
            child = parent * 2 + 1;
        }

如果父子逆序，只需要交换父子。需要注意的是：完成一次交换之后，需要更新父子的下标，完成迭代。

else    //前提是，其余元素已经是个堆结构
    break;

若不需要交换，可以直接跳出堆结构。

简而言之，向下调整算法就是：先找孩子，逆序交换，顺序跳出。

介绍完调整算法，便可以介绍排序算法。

进行堆排序时，需要两个步骤：1.向下调整算法建堆 2.向下调整算法排序。

1.建堆过程

    for (int i = (n - 1 - 1) / 2; i >= 0; i--)        //i从倒数第一个父亲开始，不断--，不断建好堆的每一部分{AdjustDown(a, n, i);}

int end = n - 1;while (end > 0)
{Swap(&a[end], &a[0]);AdjustDown(a, end, 0);		//从根开始向下调整, 新数组大小是endend--;	
}

void HeapSort(int* a, int n)
{//1.向下调整算法建堆 ：传父亲下标for (int i = (n - 1 - 1) / 2; i >= 0; i--)		//i从倒数第一个父亲开始，不断--，不断建好堆的每一部分{AdjustDown(a, n, i);}//2.向下调整算法排序: 不断筛选最大值，放到数组末尾int end = n - 1;while (end > 0){Swap(&a[end], &a[0]);AdjustDown(a, end, 0);		//从根开始向下调整, 新数组大小是endend--;	}}

void BubbleSort(int* a, int n)
{for (int i = 0; i < n - 1; i++)		//趟数（类比插入排序的趟数）{bool exchange = false;for (int j = 0; j < n - 1 - i; j++){if (a[j] > a[j + 1])		//每两个元素，一一比较{Swap(&a[j], &a[j + 1]);exchange = true;}}if (exchange == false)		//当某一趟没有发生交换，说明已经有序，则直接跳出循环break;}}

任取待排序元素序列中 的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

可以观察到，其思想是先利用单趟排序，使得单趟有序，再分别对子区间排序，因此便衍生出了递归版本和非递归实现的版本。

//Hoare法
int PartSort1(int* a, int left, int right)
{int keyi = left;while (left < right)	//右找小；左找大{while (left < right && a[right] >= a[keyi])			//左边是key，右边先走right--;		while (left < right && a[left] <= a[keyi])		//防止越界 与 死循环left++;//到此处时，一定是找到了大和小Swap(&a[left], &a[right]);		//体现交换排序}//相遇Swap(&a[left], &a[keyi]);	//最后相遇，让数据key和相遇位置的数据（比key小）交换keyi = left;return keyi;}

情况一;R停下来时，一定是找到了  --- 小

情况二：L停下时，一定是刚交换完的之后 ----  小

算法优化

此算法的时间复杂度目前代码是n^2，主要原因是key的取值，如果keyi每次取最左边，如果原数组有序，则会形成等差数列的复杂度，造成n^2。

分析：

//如果已经有序，每次取得是最左边的数，则左边是一个不存在的区间，右边则会形成等差数列一共进行n - 1次调用（每次深度 - 1），每一次调用的循环规模是n - 1， n - 2, n - 3.

//则时间复杂度是所有规模之和，n + n - 1 + n - 2 + .....

优化后：

了解到主要原因是处在key的取值后，那便尽量让key的取值接近中位数。此时便出现三数取中。

三数取中

比较头、中、尾三个元素的大小，取中间值作为key

以下是三位取中的实现

//优化版：三数取中法(两两比较）int GetMidIndex(int* a, int left, int right)			//取下标
{int mid = (left + right) >> 1;		//÷2if (a[left] < a[mid]){if (a[mid] <= a[right])return mid;else if (a[left] <= a[right])		//走到此处，前提条件一定是 a[left] >= a[right]return right;elsereturn left;}else	//一定是a[left] >= a[mid]{if (a[mid] >= a[right])return mid;else if (a[left] <= a[right])	//此时一定是a[mid] < a[right]return left;elsereturn right;}}

得到中间值的下标之后，只需要让中间值与左边的值交换，便可以仍然让左边的值作为key

int midi = GetMidIndex(a, left, right);    //三数取中，记录Index
Swap(&a[midi], &a[left]);        //始终让最左边的数是“中”

2.挖坑法

其思想仍然是让左边小于key，右边大于key，分割出两段区间。

//挖坑
int PartSort2(int* a, int left, int right)
{int midi = GetMidIndex(a, left, right);    //三数取中，记录IndexSwap(&a[midi], &a[left]);int key = a[left];    //keyint hole = left;    //假设最开始left是坑的位置while (left < right)    //左找大，右找小{while (left < right && a[right] >= key)    //找数据right--;//交换数据，填洞Swap(&a[right], &a[hole]);        //交换数据，拿当前数据填坑hole = right;                //自己形成新的坑while (right > left && a[left] <= key)left++;Swap(&a[left], &a[hole]);hole = left;}//最后相遇，相遇在坑处（其中一个一定是坑，那么相遇一定是相遇在坑处）a[hole] = key;        //形成三个区间，左边比key小，右边比key大，最后相遇被key填上return hole;    //返回最后一个坑的位置} 

仍然是右边先找小，再左边找大，只不过区别是，每次找到之后，都要去填坑，形成新的坑。

最后key填到相遇的位置（hole中）。

前后指针法

可以说是最简单的一种版本了，至于要定义两个下标 prev 和 cur（是下标，不是数据），遍历数组就好。

过程：

通过此操作，使得大于key的值，不断翻滚向前，prev与cur夹杂的数据就是大于key的数据。

        

//前后指针法
int PartSort3(int* a, int left, int right)
{int cur = left + 1;int prev = left;		//不能是 0， 应该是left端点 int midi = GetMidIndex(a, left, right);	//三数取中，记录IndexSwap(&a[midi], &a[left]);int keyi = left;while (cur <= right)		//闭区间{if (a[cur] < a[keyi] && ++prev != cur)			//找到小，prev++；再交换Swap(&a[cur], &a[prev]);cur++;}Swap(&a[prev], &a[keyi]);		//交换数据，挪动keyi的位置，形成三个子区间keyi = prev;return keyi;}

找完之后，让再交换keyi与prev处的值，让keyi到prev处，从而分割出两段区间。

/*

三种子排序，都是形成了 左 keyi 右 三个区间

快排一般用前后指针法

cur找小，prev++，交换  （cur 与 prev最开始相邻）

最后交换a[prev] 与 a[keyi]

keyi = prev；
return keyi；   

*/
 

讲解完三种子排序，便可以讲解快排。

递归版本

//类似二叉树的展开，左边完成之后，再走右边
void QuickSort(int* a, int begin, int end)		//三种子排序，最终思想都是左边比key小，右边比key大，中间是keyi
{if (begin >= end)return;int keyi = PartSort3(a, begin, end);		//单趟排序//[left, keyi - 1] keyi [keyi + 1, end]QuickSort(a, begin, keyi - 1);	//利用单趟排序的返回值，左区间重复QuickSort(a, keyi + 1, end);	//右边重复
}

每次子排序，都会形成[left, keyi - 1] keyi [keyi + 1, end]两段区间，再利用这两段区间，分别进行子排序。（类似于二叉树的先序遍历）

非递归版本

由于其递归过程形似二叉树的展开过程，因此非递归借助栈来实现。

基本思想：1.利用栈的后进先出 2.当大区间完成排序之后，带入子区间进入栈

//循环：入  +  出 + 功能操作
void QuickSortNonR(int* a, int begin, int end)	//快排非递归利用栈实现(深度优先）
{ST st;STInit(&st);	STPush(&st, end);STPush(&st, begin);while (!STEmpty(&st)){int left = STTop(&st);STPop(&st);int right = STTop(&st);STPop(&st);int keyi = PartSort3(a, left, right);//[left, keyi - 1] keyi [keyi + 1, right]if (keyi + 1 < right)	//只有一个元素不需要排序{STPush(&st, right);STPush(&st, keyi + 1);}if (left < keyi - 1){STPush(&st, keyi - 1);STPush(&st, left);}}STDestroy(&st);}

在此段代码中，先押入右再压入左，则先取左，再取右

        int keyi = PartSort3(a, left, right);
        //[left, keyi - 1] keyi [keyi + 1, right]

每次调用单趟排序之后，都会形成两段区间。

    STDestroy(&st);用完之后，将栈空间销毁。

快速排序的特性总结：

1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(logN)        //递归调用深度
4. 稳定性：不稳定

5.三种方法都无法解决有大量重复元素的问题。

解决：三路划分法 + 随机数取中

三路划分更全面，但是右路的原因，造成效率下降（日常写快排还是hoare和前后指针）

1.随机数取中 ：

让mid取[left, end]区间的任意一个数

（left  + rand（） / （right - left）)此时取出的mid值，保证是区间内的任意值

rand % x ，保证结果小于x 因此 left + x < right;

2.三路划分法

当有大量重复元素时，每次让左边的值为key，则剩下的递归区间：左区间没有，有区间为n - i （i为递归次数），此时变成最坏情况

解决本质：

小的放在左边，大的放到右边，等于key的集中中间

将等于key的数据，放到中间，每次只对小于的部分和大于的部分进行划分

在过程中，left与right不断靠近中间

既有hoare的思想，也有前后指针的思想。

1.小的往左甩，大的往右甩right--

2.把等于key的值，往中间推

往右甩不会影响，所以不需要++c。往右甩有三种情况，大于等于 相等

在++Cur的过程中，始终保持left位置处的值 == key

最终left 与  right区间中的数据就是与key相等数据

[begin，left - 1]      [left， right]         [right + 1 ，end] 最终可形成这三段区间。

核心代码：

void QuickSort(int* nums, int begin, int end)
{if (begin >= end)return;int left = begin;int right = end;int cur = left + 1;int midi = MidIndex(nums, begin, end);Swap(&nums[midi], &nums[left]);int key = nums[left];while (cur <= right){if (nums[cur] < key)    //cur是下标，不是具体元素{Swap(&nums[cur], &nums[left]);      //分别和；；left和right处的值换，让left与right再不断移动，靠近中间 left++; cur++;}else if (nums[cur] > key){Swap(&nums[cur], &nums[right]);right--;}elsecur++;}QuickSort(nums, begin, left - 1);QuickSort(nums, right + 1, end);}

最终left，right区间夹杂的数据就是等于key的值。

例子：

给你一个整数数组 nums，请你将该数组升序排列。（需要解决三种方法都无法解决有大量重复元素的问题。）

示例 1：

输入：nums = [5,2,3,1]
输出：[1,2,3,5]

示例 2：

输入：nums = [5,1,1,2,0,0]
输出：[0,0,1,1,2,5]

提示：

• 1 <= nums.length <= 5 * 104
• -5 * 104 <= nums[i] <= 5 * 104

解决代码：

int MidIndex(int* nums, int left, int right)
{int mid = left + (rand() % (right - left));     //中间值变化//rand % x ，保证结果小于x 因此 left + x < right;if (nums[left] < nums[mid]){if (nums[mid] <= nums[right])return mid;if (nums[left] <= nums[right])return right;elsereturn left;}else{if (nums[left] <= nums[right])return left;if (nums[mid] <= nums[right])return right;elsereturn mid;}}void Swap(int* a, int* b)
{int tmp = *a;*a = *b;*b = tmp;
}//优化：三路划分法 + 随机数取中void QuickSort(int* nums, int begin, int end)
{if (begin >= end)return;int left = begin;int right = end;int cur = left + 1;int midi = MidIndex(nums, begin, end);Swap(&nums[midi], &nums[left]);int key = nums[left];while (cur <= right){if (nums[cur] < key)    //cur是下标，不是具体元素{Swap(&nums[cur], &nums[left]);      //分别和；；left和right处的值换，让left与right再不断移动，靠近中间 left++; cur++;}else if (nums[cur] > key){Swap(&nums[cur], &nums[right]);right--;}elsecur++;}QuickSort(nums, begin, left - 1);QuickSort(nums, right + 1, end);}int* sortArray(int* nums, int numsSize, int* returnSize) {srand(time(0));int begin = 0;int end = numsSize - 1;QuickSort(nums, begin, end);*returnSize = numsSize;     //传入的returnSize是一个指针，需要人为赋值return nums;
}

归并排序

顾名思义，是通过两个数组的归并完成的排序。

基本思想：
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

其具体思想是：将大区间拆分成一个个小区间，再两两归并，再拷贝回原来的区间。

递归版

//1.拆分  2.归并
void _MergeSort(int* a, int begin, int end, int* tmp)
{if (begin == end)return;int mid = (begin + end) / 2;//拆分 [begin, mid] [mid + 1, end]_MergeSort(a, begin, mid, tmp);_MergeSort(a, mid + 1, end, tmp);//归并int begin1 = begin;   int end1 = mid;int begin2 = mid + 1; int end2 = end;int i = begin;	// i 丛begin 开始，而不是从 0 开始，  tmp数组随a从begin位置开始拷贝while (begin1 <= end1 && begin2 <= end2)	//尾插{if (a[begin1] <= a[begin2])tmp[i++] = a[begin1++];		//begin1 和 begin2 不能同时++，只有用完之后才能++elsetmp[i++] = a[begin2++];}while (begin1 <= end1)	//到此处一定有一个结束{tmp[i++] = a[begin1++];}while (begin2 <= end2)	{tmp[i++] = a[begin2++];}memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));	//不是只拷贝前几个字节，而是拷贝完成内容修改的部分
}//需要注意的是，尾插从begin处开始，拷贝回去也是从begin处开始。

void MergeSort(int* a, int n)
{int* tmp = (int*)malloc(sizeof(int) * n);_MergeSort(a, 0, n - 1, tmp);		//n是数组大小，n - 1才是下标free(tmp);tmp = NULL;
}

以下体现的是拆分

    //拆分 [begin, mid] [mid + 1, end]
    _MergeSort(a, begin, mid, tmp);
    _MergeSort(a, mid + 1, end, tmp);

以下体现的是归并

int begin1 = begin;   int end1 = mid;
int begin2 = mid + 1; int end2 = end;

int i = begin;    // i 丛begin 开始，而不是从 0 开始，  tmp数组随a从begin位置开始拷贝
while (begin1 <= end1 && begin2 <= end2)    //尾插    //只有一个元素时，begin == end
{
    if (a[begin1] <= a[begin2])
        tmp[i++] = a[begin1++];        //begin1 和 begin2 不能同时++，只有用完之后才能++

    else
        tmp[i++] = a[begin2++];
}

while (begin1 <= end1)    //到此处一定有一个结束
{
    tmp[i++] = a[begin1++];
}

while (begin2 <= end2)    
{
    tmp[i++] = a[begin2++];
}
 

最后需要拷贝回去。

需要注意的是，并归到tmp数组时，需要从begin处开始并归，因此拷贝回去，也是从此处拷贝回去。

非递归版

对于递归，可以完成层层拆分；对于非递归，则需要借助gap来完成小组之间的递归

大体可以看作两步

1.三层循环嵌套 2.进行参数调整，防止出现越界。

void MergeSortNonR(int* a, int n)
{int* tmp = (int*)malloc(sizeof(int) * n);int gap = 1;	//表示两个begin1 之间的元素个数while (gap < n){	int j = 0;for (int i = 0; i < n; i += 2 * gap){int begin1 = i; int end1 = i + gap - 1;	//end下标是  begin下标 + 间隔元素个数 - 1 int begin2 = end1 + 1; int end2 = begin2 + gap - 1;//三种越界if (end1 >= n || begin2 >= n)break;if (end2 >= n)end2 = n - 1;while (begin1 <= end1 && begin2 <= end2){if (a[begin1] <= a[begin2])tmp[j++] = a[begin1++];elsetmp[j++] = a[begin2++];}while (begin1 <= end1){tmp[j++] = a[begin1++];}while (begin2 <= end2){tmp[j++] = a[begin2++];}//完成一组，拷贝一组memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));	//闭区间元素个数需要 + 1}gap *= 2;}free(tmp);tmp = NULL;}

1.三层嵌套讲解

不同于快排的非递归实现，快排的非递归实现借助的是栈，这是因为其区间变化是从大到小，类比二叉树。

并归排序的非递归采用的是从前到后分割区间，因此可以用gap来分割。

首先是gap  < n，保证了循环过程中，不能出现数组越界。

再者是        for (int i = 0; i < n; i += 2 * gap) 通过 i 来生成两两归并的起点

最后是        while (begin1 <= end1 && begin2 <= end2) 来完成归并。

简而言之就是：1.控gap 2.控起点 3.完归并

2.越界讲解。

此处越界，可分为三种情况，

三种越界图示：

对于第一第二种情况，只需要让循环终止即可，通过归并一组，拷贝一组，只需要让归并的部分拷贝到原数组即可

对于第三种情况，只需要让end2修改成n - 1即可（没必要让进行两个归并的数组大小非得相同）。

需要注意的是：

 ①   int begin1 = i; int end1 = i + gap - 1;    //end下标是  begin下标 + 间隔元素个数 - 1 
    int begin2 = end1 + 1; int end2 = begin2 + gap - 1;

对于bg1 和 end1，最开始只指向一个元素，两者重合。同时end是下标，其值为 begin的下标 + 间隔元素个数 - 1。

② if (a[begin1] <= a[begin2])
                tmp[j++] = a[begin1++];

else
                tmp[j++] = a[begin2++];

在归并时，不能同时让begin1 和 begin2同时++，只有用到时，才可以++

③若把j定义在次循环外部，则 j 可以定义为0，没完成一趟遍历（归并完一整组，j会重新变成0，重新用尾插的方式，归并到tmp数组

④同理，从begin位置开始归并，归并一组，拷贝一组，因此拷贝也要从begin处进行

            memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));    //闭区间元素个数需要 + 1
每次拷贝的元素个数是end2 - i + 1（下标 + 1 == 元素个数； 元素个数 - 1 == 下标）

⑤i += 2*gap （两个begin1之间间隔2*gap个元素）

⑥完成一大趟并归之后，gap *= 2 （先是 一一归并，再是两两归并……）

    free(tmp);
    tmp = NULL;
归并完成之后，释放空间。

归并排序的特性总结：

1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(N)
4. 稳定性：稳定

（另外多提一嘴，归并排序和快排是在工程项目中最常用的两种排序，因为两者快、高效且一个稳定，一个不稳定，可以达到效果互补）

计数排序

计数排序是一个比较有趣的排序方法，体现在两点：1.不需要进行数据的比较 2.效率忽高忽低

就拿吃席举例子，那么小孩桌坐的是：冒泡排序、插入排序、直接基数排序

大人桌坐的是：快排、并归、希尔、堆排序

计数排序比较特殊，如果去大人桌，那么他喝酒比大人还牛；但如果去小孩桌，那他喝饮料都和不过小孩。

非比较排序
思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤：
1. 统计相同元素出现次数
2. 根据统计的结果将序列回收到原来的序列中

简单来说就是 ：

1.建立一个count（tmp）数组，来统计原数组种数据出现的个数

2.tmp数组中的数据，按照顺序映射回原数组。

表达式： tmp数组下标 == 数据值 - min

void CountSort(int* a, int n)
{int max = a[0];int min = a[0];//求max 与 minfor (int i = 0; i < n; i++){if (a[i] > max)max = a[i];if (a[i] < min)min = a[i];}int range = max - min + 1;int* tmp = (int*)malloc(sizeof(int) * range);memset(tmp, 0, sizeof(int) * range);	//每个字节都被初始化为数字0。 不能是字符 '0' （字符‘0’存储的ASC II值不是数字0）if (tmp == NULL){perror("malloc fail");return;}//相对映射for (int i = 0; i < n; i++){tmp[a[i] - min]++;}//映射到原数组int j = 0;for (int i = 0; i < range; i++)		//遍历tmp计数数组时，开辟的空间大小是range，而不是n{while (tmp[i]--)	//1.不为0  2.看次数（count）{a[j++] = i + min;}}free(tmp);tmp = NULL;
}

观察代码不难发现，此处需要三个循环。

循环一：遍历原数组，找max与min

循环二：遍历原数组，将原数组的数据，映射到tmp数组，当出现相同的元素时，对应tmp数组的元素++

循环三：遍历tmp数组（大小是range），将元素拷贝回原数组。

需要注意的是

① 

tmp[a[i] - min]++;

a[j++] = i + min;

这两段代码，便体现了tmp数组的下标 == 有效数据大小 - min的特点。

完成之后，释放空间。

②

memset(tmp, 0, sizeof(int) * range);

需要对tmp数组所有数据初始化为数字0。

③

for (int i = 0; i < range; i++)        //遍历tmp计数数组时，开辟的空间大小是range，而不是n
{
    while (tmp[i]--)    //1.不为0  2.看次数（count）
    {
        a[j++] = i + min;
    }

}

第三次遍历tmp数组时，由于tmp数组元素被初始化为0，因此可以直接while(tmp[i]--)

既可以保证不为0，同时不为0时，还可以根据被统计的次数不断--，通过a[j++] = i  +  min；给数组a排序。

计数排序的特性总结：

1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
2. 时间复杂度：O(MAX(N,范围))
3. 空间复杂度：O(范围)
比特科技
4. 稳定性：稳定

由此便可以知道为什么说计数排序是一个有趣的排序，观察空间复杂度，当数据比较集中时，range很小，空间复杂度极低；同时时间按复杂度变为O(N) 比快排还要优秀许多倍！！！同时稳定性也良好！

但是数据过分分散时，空间复杂度及时间复杂度就变得很差。

以上便是八大内排序的常用算法。