【数据结构】排序—C语言版

七大排序算法

• 一、对于排序的分类：
• 二、插入排序
• • 1、直接插入排序
  • • （1）基本思想：
    • （2）直接插入排序：
    • （3）代码实现：
    • （4）总结：
  • 2、希尔排序
  • • （1）基本思想：
    • （2）希尔：
    • （3）代码实现：
    • （4）总结：
• 二、选择排序
• • 1、直接选择排序
  • • （1）基本思想：
    • （2）代码实现：
    • （3）总结：
  • 2、堆排序
  • • （1）基本思想：
    • （2）代码实现：
    • （3）总结：
• 三、交换排序
• • 1、冒泡排序
  • • （1）基本思想：
    • （2）代码实现：
  • 2、快速排序
  • • （1）基本思想
    • （2）霍尔原版
    • （3）三数取中的加持
    • （4）挖坑法
    • （5）前后指针法
    • （6）快排—非递归
    • （7）总结：
• 四、归并排序
• • 1.归并—递归版
  • • （1）基本思想：
    • （2）代码实现：
    • （3）总结：
  • 2、归并—非递归版
  • • （1）基本思想：
    • （2）代码实现:
• 五、计数排序（非比较排序）
• • （1）基本思想
  • （2）代码实现
  • （3）总结
• 六、排序总结
• • 稳定性的概念

一、对于排序的分类：

二、插入排序

1、直接插入排序

（1）基本思想：

直接插入排序是一种简单的插入排序法，其基本思想是：

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。（打扑克牌就是类似的思想）

（2）直接插入排序：

当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与
array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移
动图如下：

（3）代码实现：

1.头文件：

#pragma once

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>

void Swap(int* p1, int* p2);

void Insert_sort(int* arr, int n);

2.源文件：

void InsertSort(int* arr, int n)
{
	// 1.for循环,外层循环的作用：是不断让end往后走，这样就保持前面一段序列[0,end]的之间是有序的！
	for (int i = 0; i < n - 1; i++)//2.这里的循环控制条件为什么i<n-1，因为:如果i<n的话，那么最终end会走到最后一个元素的下标!
	//但是进入循环里面还有一步，你别忘了就是把arr[end+1]赋值给tmp,那end+1不就是越界了吗？
		//所以说为了防止end+1越界，那么end只能走到倒数第2个位置！
	{
		//我们要定义一个下标来控制：[0,end]是有序的
		int end=i;
		//我们先用一个临时变量tmp来暂时保存，要插入这个数据，要插入这个数据就是：下标为end+1
		int tmp = arr[end + 1];
		while (end >= 0)
		{
			if (tmp < arr[end])
			{
				arr[end + 1] = arr[end];
				end--;
			}
			else
			{
				break;
			}
		}

		arr[end + 1] = tmp;
	}
}

3.测试文件：

int main()
{
	int arr[] = { 3,5,9,2,4,6,8,0,1,7 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	InsertSort(arr, sz);
	
	
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

（4）总结：

直接插入排序的特性总结：

1. 元素集合越接近有序，直接插入排序算法的时间效率越高
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)，它是一种稳定的排序算法
4. 稳定性：稳定

2、希尔排序

（1）基本思想：

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

（2）希尔：

1.希尔排序包括：（1）预排序（2）直接插入排序
2.gap是间隔的意思，gap=X，整个数组就有X组！

（3）代码实现：

1.头文件：

#pragma once
#include<stdio.h>
#include <stdlib.h>
#include<assert.h>

//希尔排序
void ShellSort(int* arr, int n);

2.源文件：

//希尔排序

void ShellSort(int* arr, int n)
{
	int gap = n;
	//3.这个while循环gap最后一次一定要==1
	while (gap>1)
	//(1)gap>1是预排序！(2)gap==1就是插入排序！
	{
		gap = gap / 3 + 1;
		//2.一组一组地插入排序
		for (int i = 0; i < gap; i++)
		{
			//这是以gap为间隔的一组数据已经排完了
			for (int i = 0; i < n - gap; i += gap)
			{
				//1.单趟
				int end = i;
				//tmp/arr[end+1]就是要插入的数据
				int tmp = arr[end + gap];
				while (end >= 0)
				{
					if (tmp < arr[end])
					{
						arr[end + gap] = arr[end];
						end -= gap;
					}
					else
					{
						break;
					}
				}
				arr[end + gap] = tmp;
			}
		}
	}
}

3.测试文件：

#include <stdio.h>
#include "Sort.h"

ShellSort(arr, sz);
int main()
{
	int arr[] = { 3,5,9,2,4,6,8,0,1,7 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	
	ShellSort(arr, sz);
	
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

（4）总结：

希尔排序的特性总结：

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排序的时间复杂度都不固定，实验和基础上推断时间复杂度为O(N^1.3)。
4. ① 最坏的情况是逆序时，gap很大时，while循环的时间复杂度为O(N)
   ② 当gap很小时，本来应该是O(N*N) ，但是经过预排序后，数组已经接近有序，所以这里还是O(N)

二、选择排序

1、直接选择排序

（1）基本思想：

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。

（2）代码实现：

1.头文件：

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

//选择排序
void SelectSort(int* arr, int n);

2.源文件：

//选择排序
void SelectSort(int* arr, int n)
{
	//begin和end作为没有排好序的数组区间的，begin:(首)和end:(尾)
	int begin = 0;
	int end = n - 1;
	//i为遍历数组下标的移动变量
	//mini,maxi分别作为遍历过程中的最小值和最大值(下标)
	while (begin < end)
	{
		int mini = begin, 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[mini], &arr[begin]);
		//坑：如果最大值的位置就是开头的位置，最小值要放到begin的位置左边没毛病，但是开头正好是最大值，交换后最大值的数值虽然过去了，
		//但是最大值的下标仍然停留在begin的位置（也就是交换后mini的下标）所以说要把此刻mini的下标赋值给maxi下标，下标也一起带走。
		if (arr[maxi] == arr[begin])
		{
			maxi = mini;
		}
		Swap(&arr[maxi], &arr[end]);

		begin++;
		end--;
	}
}

3.测试文件：

#define _CRT_SECURE_NO_WARNINGS 1 
#include <stdio.h>

int main()
{
	int arr[] = { 10,9,8,7,6,5,4,3,2,1 };
	int sz = sizeof(arr) / sizeof(arr[0]);

	//BubbleSort(arr, sz);
	SelectSort(arr, sz);
	//HeapSort(arr, sz);
	//QuickSort3(arr, 0, sz - 1);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

（3）总结：

直接选择排序的特性总结：

• 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
• 时间复杂度：O(N^2)无论最好还是最坏都是： O(N^2)
• 空间复杂度：O(1)
• 稳定性：不稳定

2、堆排序

（1）基本思想：

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

• 建堆：利用向下调整算法（向上也可以）
• 创建一个end的变量，用来控制数组的尾
• 首尾交换后，最大值max就到了组尾，然后不把max看作堆成员！
• 在对end的之前个数字进行向下调整算法，重新构建堆

（2）代码实现：

1.头文件：

//堆排序
void HeapSort(int* arr, int n);

//向上调整
void AdjustUp(int* arr, int child);

//向下调整
void AdjustDown(int* arr, int size, int parent);

2.源文件：

//向上调整
void AdjustUp(int* arr, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
	
}

//向下调整
void AdjustDown(int* arr, int size, int parent)
{
	int child = parent * 2 + 1;
	//建大堆：假设左孩子最大，如果不行再调换。
	while (child < size)
	{
		if (child+1 < size && arr[child] < arr[child + 1])
		{
			child++;
		}
		//运行到此处，child就是左右子树中最大的
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//堆排序
void HeapSort(int* arr, int n)
{
	//向上调整建大堆：
	for (int i = 0; i < n; i++)
	{
		AdjustUp(arr, i);
	}
	//开始堆排序
	int end = n - 1;//end是数组中最后一个元素的下标！！！
	while (end > 0)
	{
		Swap(&arr[0], &arr[end]);
		AdjustDown(arr, end, 0);//此处不要管最后一个元素end的大小，这里传的end就是size！
		end--;
	}
}

3.测试文件：

#define _CRT_SECURE_NO_WARNINGS 1 
#include <stdio.h>

int main()
{
	int arr[] = { 10,9,8,7,6,5,4,3,2,1 };
	int sz = sizeof(arr) / sizeof(arr[0]);

	//BubbleSort(arr, sz);
	//SelectSort(arr, sz);
	HeapSort(arr, sz);
	//QuickSort3(arr, 0, sz - 1);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

（3）总结：

1. 堆排序使用堆来选数，效率就高了很多。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

三、交换排序

1、冒泡排序

（1）基本思想：

依次比较相邻的两个数，将较小数放在前面，较大数放在后面，如此继续，直到比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至全部排序完成

• 在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
• 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
• 在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

（2）代码实现：

1.头文件:

#pragma once

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
void Bubble_sort(int* arr, int n);

2.源文件：

//2.冒泡排序
//时间复杂度：最坏：O(N^2)，最好：O(N)

void Bubble_sort(int* arr, int n)
{
	//1.外层循环是：趟数！(假设有10个元素需要进行9趟，所以说有n个元素就进行n-1趟。)
	for (int i = 0; i < n - 1; i++)
	{
		//标记
		bool flag = true;
		//2.内层循环是：每一趟所比较的对数！(外层循环进行一次，说明有一个元素已经对号入座了，每趟所比较的对数都会依次减小，所以说与i挂钩,要-i。)
		for (int j = 0; j < n - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				Swap(&arr[j], &arr[j + 1]);
				flag = false;
			}
		}
		if (flag == true)
		{
			printf("数组原本就是有序的！");
			break;
		}
	}
}

3.测试文件：

int main()
{
	int arr[] = { 3,5,6,2,9,10,1,7,4,8 };
	int sz = sizeof(arr) / sizeof(arr[0]);

	Bubble_sort(arr, sz);
	

	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

2、快速排序

（1）基本思想

（2）霍尔原版

// 快速排序hoare版本
void QuickSort1(int* arr, int begin, int end)
{
	//递归的最小区间！！！
	if (begin >= end)
		return;

	// Begin和end是控制未排好序的数字区间的首和尾
	// Left和right是遍历数组的移动下标
	int left = begin, right = end;
	int keyi = begin;
	while (left < right)
	{
		//右边找小
		while (left < right && arr[right] >= arr[keyi])
			right--;
		//左边找大
		while (left < right && arr[left] <= arr[keyi])
			left++;
		Swap(&arr[left], &arr[right]);
	}

	Swap(&arr[keyi], &arr[left]);
 
	//keyi要更新！！！
 
	keyi = left;//假设此时有10个数，相遇位置/最中间的数，的下标是5，即：（left），我把：下标5，赋值给了keyi！接下来我就可以：分段递归了！
	//下面的递归分为三部分：[begin,keyi-1],keyi,[keyi+1,end]
	QuickSort1(arr, begin, keyi - 1);
	QuickSort1(arr, keyi + 1, end);
}

1.原版霍尔所需要注意的细节：

2.思考：当选取数组中最左边的数据为key，为什么相遇位置的值一定比key小？
答：因为是右边先走
相遇有两种情况：

1. R遇到L：R没有找到比key小的，一直走直到遇到了L，相遇位置的值就是L，L所停留的位置一定比k小，因为L找大
2. L遇到R：R先走，找到小的就停了下来。L找大的没有找到，一直走，直到遇到R就停下来了，相遇位置是R一定比key小

（3）三数取中的加持

//三数取中：返回的是下标！！！
int GetMid(int* arr, int begin, int end)
{
	int midi = (begin + end) / 2;
	//在begin midi end中取中位数
	if (arr[begin] < arr[midi])
	{
		if (arr[midi] < arr[end])
			return midi;
		
		else if (arr[begin] > arr[end])
			return begin;
	
		else
			return end;
	}
	else //arr[begin]>arr[midi]
	{
		if (arr[midi] > arr[end])
			return midi;
		else if (arr[begin] < arr[end])
		
			return begin;
		else
			return end;
	}
}

三数取中取的是一组数据的中位数，直接找到这组数据的中位数，把多把它当做key，然后交换到最开始的第1个位置,这样就会很方便!

（4）挖坑法

//2.挖坑法
int QuickSort2(int* a, int begin, int end)
{
	
	int midi = GetMidi(a, begin, end);
	Swap(&a[begin], &a[midi]);
	int key = a[begin];//（1）挖：把开头的begin对应的下标的值挖出去赋给：key
	int holei = begin;//（2）设：key的位置为第一个坑位！

	while (begin < end)
	{
		//右边找小，放入坑位
		while (begin<end && a[end]>=key)
		{
			end--;
		}
		a[holei] = a[end];
		holei = end;

		//左边找大，放入坑位
		while (begin < end && a[begin] <= key)
		{
			begin++;
		}
		a[holei] = a[begin];
		holei = begin;
	}
	a[holei] = key;
	
	return holei;
}
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;
	//int keyi = QuickSort1(a, begin, end);

	int keyi = QuickSort2(a, begin, end);
	//int keyi = QuickSort3(a, begin, end);

	//[begin,keyi-1],keyi,[keyi+1,end]

	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi+1, end);

}

（5）前后指针法

//3.前后指针法
int QuickSort3(int* a, int begin, int end)
{
	
	int midi = GetMidi(a, begin, end);
	Swap(&a[midi], &a[begin]);

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

	while (cur <= end)
	{
		if (a[cur] <= a[keyi])
		{
			prev++;
			Swap(&a[prev], &a[cur]);
			cur++;
		}
		else//cur和prev之间的数据永远都大于key！！！
		{
			cur++;
		}
	}
	Swap(&a[prev], &a[keyi]);
	
	return prev;
}
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;
	//int keyi = QuickSort1(a, begin, end);

	//int keyi = QuickSort2(a, begin, end);
	int keyi = QuickSort3(a, begin, end);

	//[begin,keyi-1],keyi,[keyi+1,end]

	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi+1, end);

}

注意：挖坑法和前后指针法，只是理解上更容易理解，但是性能上跟原版的霍尔是一样的，没有变化。

（6）快排—非递归

1.递归—>非递归
（1）循环
（2）借助栈
2.思路：
整个区间入栈—>出栈—>单趟排序（得到key，分割成了2个子区间）—>子区间入栈（注意：后进先出）—>出栈（其中一个子区间）…
整个循环：（入栈）—>（出栈）—>（单趟排序）

//非递归快排：(入栈)->(出栈)->(单趟排序)->(入栈)......
void QuickSortNonR(int* a, int begin, int end)
{
	ST s;
	STInit(&s);

	//1.先将整个区间(入栈)，再进行循环判断。
	STPush(&s, end);
	STPush(&s, begin);

	//如果栈为空直接结束排序
	while (!STEmpty(&s))
	{
		//2.(出栈)
		int left = STTop(&s);
		STPop(&s);
		int right = STTop(&s);
		STPop(&s);

		//3.(单趟排序)进行单趟排序之后就会分为两个区间
		int keyi=QuickSort3(a, left, right);
		//[left,keyi-1],keyi,[keyi+1,right]
		
		//！！！入栈前对小区间进行判断，如果没必要入栈就直接结束
		if (left < keyi - 1)//(=)：一个值，(>)：为NULL
		{
			STPush(&s, keyi - 1);
			STPush(&s, left);
		}
		if (keyi + 1 < right)
		{
			STPush(&s, right);
			STPush(&s, keyi+1);
		}
	}
	STDestroy(&s);
}

（7）总结：

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

四、归并排序

1.归并—递归版

（1）基本思想：

归并排序：实质上就是：后续排序
基本思想：

• 先将所有的分割成最小单位（最小单位就是一个节点，一个节点就当做有序）
• 然后再归并合到一起形成有序
  思路：（原数组·：a，开辟的数组：tmp）
• 首先动态开辟一个tmp数组空间
• 数组a分解后，tmp从a数组中取出(11)归（22）归（44）归，每归并好一小段就直接拷贝回去

（2）代码实现：

1.头文件：

#pragma once


#include <stdio.h>
#include <string.h>
#include <stdlib.h>



void MergeSort(int* a, int n);

void _MergeSort(int* a, int begin, int end,int* tmp);

2.源文件：

#define _CRT_SECURE_NO_WARNINGS 1 
#include <stdio.h>
#include "sort.h"


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, end1 = mid;
	int begin2 = mid + 1, end2 = end;

	int i = begin;
	//合并两个有序数组，取小的尾插
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		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));
}


void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}

	_MergeSort(a, 0, n - 1,tmp);

	free(tmp);
}

思考细节：
MergeSort为啥要设置一个子函数：_MergeSort？
1.因为在递归的时候必须是一段区间，而函数MergeSort没有写区间，在子函数中写区间begin和end的控制区间！
2.每次递归调用自己的时候，不可能每次都开辟空间吧，因为开辟空间这个过程是在原函数MergeSort完成的。
3. malloc tmp 之后记得free(tmp);

（3）总结：

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

2、归并—非递归版

（1）基本思想：

gap:归并每组的数据个数

非递归可以控制每次的gap成倍增长来达到归并的目的，但gap成倍增长也可能会带来这样的问题

（1）第一个区间的元素个数=gap，第二个区间的元素个数<gap

（2）第一个区间的元素个数<=gap，第二个区间的元素不存在

以上这两个问题需要用边界处理来解决

（2）代码实现:

1.头文件：

#pragma once


#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void MergeSortNonR(int* a, int n);

2.源文件：

#define _CRT_SECURE_NO_WARNINGS 1 
#include <stdio.h>
#include "sort.h"

void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}

	//gap:每次归并 每组的数据个数
	int gap = 1;

	while (gap < n)//n是元素个数！！！
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			int begin1 = i, end1 = i + gap - 1;//第一组
			int begin2 = i + gap, end2 = i + 2 * gap - 1;//第二组

			//归并前：边界处理！！！
			//因为数组的大小不可能正好是2^n倍

			if (end1 >= n || begin2 >= n)
			{
				break;
			}

			if (end2 >= n)
			{
				end2 = n-1;
			}

			int j = begin1;

			//归并
			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));
		}
		gap *= 2;
	}
	free(tmp);
}

3.测试文件：

#define _CRT_SECURE_NO_WARNINGS 1 
#include <stdio.h>
#include "sort.h"

int main()
{

	int a[] = { 2,4,5,6,1,7,3,2,0,6 };
	int sz = sizeof(a) / sizeof(a[0]);
	MergeSortNonR(a, sz);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

五、计数排序（非比较排序）

（1）基本思想

原理：用另一个数组统计原数组中相同元素出现的次数，再根据统计次数反向填充到原数组中

如果相对集中的数据还可以很好写，但是如果分散间距很大的数据，用这种绝对映射是不行的！
所以说我们要引出一个相对映射的概念
比如说我有1000，1999，1888…等等100个数据,如果我开2000个空间，有些地方都没有用到，就是浪费！所以说我们要用相对映射的概念
相对映射的第1步：就是先求出一组数据的最小值（min）和最大值（max）

（2）代码实现

//计数排序

void CountSort(int* a, int n)
{
	//1.利用相对路径：需要先求出min和max
	int min = a[0];
	int max = a[0];

	for (int i = 0; i < n; i++)
	{
		if (a[i] < min)
			min = a[i];
		if (a[i] > max)
			max = a[i];
	}
	//2.创建一个count数组且初始化均为0
	int range = max - min + 1;//相对路径

	int* count = (int*)calloc(range, sizeof(int));
	if (count == NULL)
	{
		perror("calloc fail");
		return;
	}

	//3.统计各个数据出现的次数
	for (int i = 0; i < n; i++)
	{
		count[a[i] - min]++;
	}

	int i = 0;	//i：遍历a数组的下标
				//j：遍历count数组的下标
	//4.排序
	for (int j = 0; j < range; j++)
	{
		while (count[j]--)//注意判断条件：count[j](出现的次数)！！！如果出现零次，我都没必要进行排序，就不会进入这个循环。
			//对于1个数字出现多次，所以要count[j]--
		{
			a[i++] = j + min;
		}
	}

}

（3）总结

适用场景：待排序数组的范围比较集中，效率就高，否则Count数组长度很长，浪费空间；且只适合整数，浮点数和字符串不适用。

时间复杂度：O(n+range)
空间复杂度：O(n)

六、排序总结

稳定性的概念

如果数组中有多个相同的值，排序后还能够保证还能这几个相同的值其相对顺序不变，那么该排序算法具有稳定性。

好了，今天的分享就到这里了
如果对你有帮助，记得点赞👍+关注哦！
我的主页还有其他文章，欢迎学习指点。关注我，让我们一起学习，一起成长吧！