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

			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);		//从根开始向下调整, 新数组大小是end
	end--;	
}

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);		//从根开始向下调整, 新数组大小是end
		end--;	
	}

}

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;		//÷2

	if (a[left] < a[mid])
	{
		if (a[mid] <= a[right])
			return mid;

		else if (a[left] <= a[right])		//走到此处，前提条件一定是 a[left] >= a[right]
			return right;

		else
			return 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;

		else
			return 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);    //三数取中，记录Index
    Swap(&a[midi], &a[left]);

    int key = a[left];    //key
    int 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);	//三数取中，记录Index
	Swap(&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--;
        }

        else
            cur++;

    }



    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;
        
        else
            return left;
    }
    
    else
    {
        if (nums[left] <= nums[right])
            return left;
        
        if (nums[mid] <= nums[right])
            return right;
        
        else
            return 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--;
        }

        else
            cur++;

    }



    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 不能同时++，只有用完之后才能++

		else
			tmp[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++];

				else
					tmp[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 与 min
	for (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) 比快排还要优秀许多倍！！！同时稳定性也良好！

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

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