数据结构之八大排序算法_数据结构使用排列运算

一.常见的排序

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
下面是常见的排序算法：

// 插入排序
void InsertSort(int* a, int n);
//希尔排序
void ShellSort(int* a, int n);
// 选择排序
void SelectSort(int* a, int n);
// 堆排序
void AdjustDwon(int* a, int n, int root);
void HeapSort(int* a, int n);
// 冒泡排序
void BubbleSort(int* a, int n)
// 快速排序递归实现
// 快速排序hoare版本
int PartSort1(int* a, int left, int right);
// 快速排序挖坑法
int PartSort2(int* a, int left, int right);
// 快速排序前后指针法
int PartSort3(int* a, int left, int right);
void QuickSort(int* a, int left, int right);
// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right)
// 归并排序递归实现
void MergeSort(int* a, int n)
// 归并排序非递归实现
void MergeSortNonR(int* a, int n)
// 计数排序
void CountSort(int* a,int n)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

二.插入排序

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

把待排序的元素按其值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列

实际中我们玩扑克牌时，就用了插入排序的思想：

具体步骤：

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

代码实现：

void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			//大于tmp，从end整体往后挪一个
			if (a[end] > tmp)        
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;          //把tmp插入空隙
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

插入排序的特点：

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

三.希尔排序

希尔排序法又称缩小增量法，其基本思想是：

先选定一个整数gap，把待排序数列中所有数据分组，所有距离为gap的分在同一组内，并对同组的元素进行排序。然后，缩小整数gap，重复上述分组和排序的工作。当gap=1时，所有记录在统一组内排好序。

代码实现：

void ShellSort(int* a, int n)
{
	int gap = n;             //间隔
	while (gap > 1)
	{
		//也可以这样写：gap/=2;       
		gap = gap / 3 + 1;   //+1是为了使gap最后等于1
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

希尔排序的特点：

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书中给出的希尔排序的时间复杂度都不固定。
   本文的gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照：O(n^1.25)到O(1.6*n^1.25) 来算。
4. 稳定性：不稳定

四.选择排序

选择排序的基本思想：

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

具体步骤：

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

如下图所示：

代码实现：

void SelectSort(int arr[], int n)
{
	//n个数，只需排好n-1个，剩下的一个自然在正确的位置上
	for (int i = 0; i < n-1; i++) 
	{
		int min = i;      //用min来记录最小值的下标
		//从下标i的后一个开始比较         
        for (int j = i+1; j < n; j++)  
		{
			if (arr[j] < arr[min])
			{
				//找到比自己小的数，更新最小值下标
				min = j;            
			}
		}
		//如果min的值改变，则与当前i处的值交换
		if (min != i)             
		{
			int tmp = arr[i];
			arr[i] = arr[min];
			arr[min] = tmp;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

选择排序的特点：

1. 选择排序好实现，但是效率不是好。
2. 时间复杂度：最好最坏平均都是O(N²)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

五.堆排序

堆排序的基本思想：

在堆的基础上设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

具体步骤：

1. 首先将待排序的数组构造成一个大根堆（升序），此时，整个数组的最大值就是堆顶

2. 将堆顶的数与堆尾的数交换，此时，堆尾的数为最大值，剩余待排序数组个数为n-1

3. 将堆顶的数进行向下调整，剩余的n-1个数再构造成大根堆，再将堆顶数与n-1位置的数交换，如此反复执行，便能得到有序数组

代码实现：

void AdjustDown(HPDataType* a, int n, int parent)
{
	assert(a);
	//先默认较大的为左孩子
	int child = parent * 2 + 1;
	while (child < n)
	{
		//如果右孩子比左孩子大，就++
		if (a[child] < a[child + 1] && child + 1 < n)
		{
			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; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
	
	//排序
	int end = n-1;
	while (end)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

（有关堆及二叉树的详细讲解请移步到此：数据结构：树与二叉树与堆）

堆排序的特点：

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

六.冒泡排序

这应该是我们最早学习的一种排序算法了，具体思想不再赘述。

代码实现：

void BubbleSort(int arr[], int n) //n为数组的大小
{
	//n个数字，把n-1个排好，剩下一个自然在正确的位置
	for (int i = 0; i < n-1; i++)
	{
		//每一个轮回之后，末端的数字已经到了正确的位置上，不需要比较
		for (int j = 0; j < n - 1 - i; j++)
		{
			//比较相邻数字
			//升序为 >，降序为 <
			if (arr[j] > arr[j + 1])
			{
				//交换两个数字的位置
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

冒泡排序的特点：

1. 冒泡排序是一种非常容易理解的排序，具有教学意义
2. 时间复杂度：平均O(N²)，最好O(N)，最坏O(N²)
3. 空间复杂度：O(1)
4. 稳定性：稳定

七.快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：

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

快速排序常见的实现方法：Hoare，挖坑法，前后指针法

1.Hoare版本

具体步骤如下图所示：

代码实现：

void Swap(int* p, int* q)
{
	int tmp = *p;
	*p = *q;
	*q = tmp;
}
 
void QuickSort(int* a, int begin, int end)
{
    //数列只有一个数或没有数，直接返回
	if (begin >= end)
	{
		return;
	}
 
	int left = begin;
	int right = end;
 
	int keyi = left;
 
	while (left < right)
	{
        //右边先走
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}
 
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
 
		Swap(&a[left], &a[right]);
	}
 
	Swap(&a[keyi], &a[left]);
 
	QuickSort(a, begin, left - 1);
	QuickSort(a, left + 1, end);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

2.挖坑法

具体步骤：

代码实现：

void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
 
	int left = begin;
	int right = end;
 
	int key = a[left];
	int hole = left;//坑位
 
	while (left < right)
	{
		while (left < right && a[right] >= key)
		{
			right--;
		}
		
		a[hole] = a[right];
		hole = right;
 
		while (left < right && a[left] <= key)
		{
			left++;
		}
 
		a[hole] = a[left];
		hole = left;
	}
 
	a[hole] = key;
 
	QuickSort(a, begin, hole - 1);
	QuickSort(a, hole + 1, end);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

3.前后指针法

具体步骤：

代码实现：

void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
 
	int prev = begin;
	int cur = prev + 1;
 
	int keyi = begin;
 
	while (cur <= end)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		
		cur++;
	}
 
	Swap(&a[keyi], &a[prev]);
	keyi = prev;
 
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

以上就是三种版本的快速排序，这三种方法并无明显的优劣之分，但是缺都存在一些隐患与缺点：

1. 在最坏情况下它的的效率极慢
   当数据本身就是有序的时候（无论是逆序还是顺序）。在最坏情况下，每次我们的 key 值都是最大或者最小，这样就会使 key 与数列的每个数都比较一次，它的时间复杂度为 O(n^2);

2. 在数据量太大时会造成栈溢出
   快速排序是利用递归实现的，有递归调用，就要建立函数栈帧，并且随着递归的深度越深所要建立的函数栈帧的消耗就越大

那么为了规避快速排序的缺点，下面介绍两种优化方式：

1.三数选中法取key

旧方法中，我们每次选 key都是数列的第一个元素。三数取中的做法是：分别取数列的第一个元素、最后一个元素和最中间的元素，选出三个数中不是最大也不是最小的那个数当作key 值。

有了三数取中法，之前的最坏情况立马变成了最好情况。

代码实现：

//三数取中的函数
int GetMidIndex(int* a, int begin, int end)
{
	int mid = (begin + end) / 2;
 
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
		{
			return mid;
		}
		else if (a[begin] > a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
	else // a[begin] > a[mid]
	{
		if (a[mid] > a[end])
		{
			return mid;
		}
		else if (a[begin] < a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
}
//hoare法
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
 
	int mid = GetMidIndex(a, begin, end);
	Swap(&a[mid], &a[begin]);
 
	int left = begin;
	int right = end;
	int keyi = left;
 
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
 
		Swap(&a[left], &a[right]);
	}
 
	Swap(&a[keyi], &a[left]);
 
	QuickSort(a, begin, left - 1);
	QuickSort(a, left + 1, end);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

2.用插入排序优化小区间

1.随着递归的调用越深入，函数栈帧的消耗会越来越大。但在同时越往下，数列就越接近有序，且此时每个小区间的数据个数特别少。
2.上文介绍插入排序时数据越接近有序，效率就越高。并且，在数据量极少的情况下，时间复杂度为 O(N²) 的插入排序与时间复杂度为 O(N*log N)的快速排序基本没有什么区别。所以，我们干脆就在排序数据量少的数列时，采用插入排序代替。

代码实现：

//三数取中的函数
int GetMidIndex(int* a, int begin, int end)
{
	int mid = (begin + end) / 2;
 
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
		{
			return mid;
		}
		else if (a[begin] > a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
	else // a[begin] > a[mid]
	{
		if (a[mid] > a[end])
		{
			return mid;
		}
		else if (a[begin] < a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
}
 
//插入排序
void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (a[end] > tmp)         //大于tmp，往后挪一个
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;          //把tmp插入空隙
	}
}
 
//hoare法
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
 
	if ((end - begin + 1) < 15)
			{
				// 小区间用直接插入替代，减少递归调用次数
				InsertSort(a+begin, end - begin + 1);
			}
	else
	{
		int mid = GetMidIndex(a, begin, end);
		Swap(&a[mid], &a[begin]);
 
		int left = begin;
		int right = end;
		int keyi = left;
 
		while (left < right)
		{
			while (left < right && a[right] >= a[keyi])
			{
				right--;
			}
			while (left < right && a[left] <= a[keyi])
			{
				left++;
			}
 
			Swap(&a[left], &a[right]);
		}
 
		Swap(&a[keyi], &a[left]);
 
		QuickSort(a, begin, left - 1);
		QuickSort(a, left + 1, end);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

如此，我们就拥有了非常完美的快速排序算法，但是以上算法都是由函数递归调用实现的，那非递归版本的快速排序该如何实现呢？

快速排序的非递归思路与递归相差无几，唯一不同的是，非递归用栈或队列模拟函数递归建立栈帧的过程。

具体步骤：

1. 先将待排序列的首位元素下标入栈。
2. 然后区间两端点下标出栈，根据栈的特点后进先出，先出的是区间右端点，后出的是区间左端点
3. 排序该区间，得到一个key值，同样根据栈的特点，先将key右侧的区间入栈，再将key左侧的区间入栈，这样先出栈的就是key左侧的区间，就可以先排序key左侧的区间了
4. 反复执行步骤2、3直到栈为空为止。

void QuickSortNonR(int* a, int begin, int end)
{
	Stack st;
	StackInit(&st);
	StackPush(&st, begin);
	StackPush(&st, end);
 
	while (!StackEmpty(&st))
	{
		int right = StackTop(&st);
		StackPop(&st);
		int left = StackTop(&st);
		StackPop(&st);
 
		int keyi = PartSort1(a, left, right);//三种方法任选其一
		//int keyi = PartSort2(a, left, right);
		//int keyi = PartSort3(a, left, right);
 
 		//根据栈后进先出的特点，我们先把右区间压入栈
		if (keyi + 1 < right)
		{
			StackPush(&st, keyi + 1);
			StackPush(&st, right);
		}
 
		if (left < keyi - 1)
		{
			StackPush(&st, left);
			StackPush(&st, keyi - 1);
		}
	}
 
	StackDestroy(&st);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

快速排序的特点：

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

八.归并排序

归并排序的基本思想为：

归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列，即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

归并排序的步骤为：


代码实现：

void _MergeSort(int* a, int begin, int end, int* tmp)
{
	//递归的结束条件//当序列只有一个元素时或序列不存在时
	if (begin >= end)
		return;
 
	//将序列进行拆分 //[begin,mid]  [mid+1,end]
	int mid = (begin + end) / 2;
 
	//拆分的过程
	_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");
		exit(-1);
	}
 
	_MergeSort(a, 0, n - 1, tmp);
 
	//释放与置空
	free(tmp);
	tmp = NULL;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

上面展示的是递归版本的归并排序，那非递归版本的归并排序该如何实现呢？

将递归改成循环迭代，每次将相邻的元素排序合并，那么第一次的排序区间长为1，第二次的排序区间长为2，第二次的排序区间长为4，第三次长为8……，最后得到一个长为n的有序数列。

但是由于 gap 每次都 *2 ，而我们排序的序列长度不可能总是 2 的倍数，所以可能会有数组越界访问的风险。例如：

有上面三种情况，下面我们一一针对每种情况做出修正：

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

	int gap = 1;
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			// [begin1,end1][begin2, end2]
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			
			//对应第2、3种情况，此时不再进行归并操作，直接跳出循环
			if (end1 >= n || begin2 >= n)
			{
				break;
			}
			//对应第1种情况，将end2调整至小于n的小区间，然后再归并
			if (end2 >= n)
			{
				end2 = n - 1;
			}

			printf("[%d,%d][%d,%d] ", begin1, end1, begin2, end2);

			int j = i;
			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));
		}

		printf("\n");

		gap *= 2;
	}

	free(tmp);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

归并排序的特点：

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

九.计数排序

计数排序的基本思想：

计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。

操作步骤：

1. 统计相同元素出现次数
2. 根据统计的结果将序列回收到原来的序列中

代码实现：

void CountSort(int* a, int n)
{
	int max = a[0], min = a[0];
	for (int i = 1; i < n; i++)
	{
		if (a[i] > max)
		{
			max = a[i];
		}
		if (a[i] < min)
		{
			min = a[i];
		}
	}
	//数的分布范围
	int range = max - min + 1;
	int* countA = (int*)malloc(sizeof(int) * range);
	if (countA == NULL)
	{
		perror("malloc fail");
		return;
	}
	memset(countA, 0, sizeof countA);
	//映射到坐标上，坐标不为负值，因此要减去最小值
	for (int i = 0; i < n; i++)
	{
		countA[a[i] - min]++;
	}
	int j = 0;
	for (int i = 0; i < range; i++)
	{
		while (countA[i]--)
		{
			a[j++] = i + min;
		}
	}
	free(countA);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

计数排序的特点：

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

说明：
虽然计数排序看上去很强大，但是它存在两大局限性：

1. 当数列最大最小值差距过大时，并不适用于计数排序：
   比如给定 20 个随机整数，范围在 0 到 1 亿之间，此时如果使用计数排序的话，就需要创建长度为 1 亿的数组，不但严重浪费了空间，而且时间复杂度也随之升高。
2. 当数列元素不是整数时，并不适用于计数排序：
   如果数列中的元素都是小数，比如 3.1415，或是 0.00000001 这样子，则无法创建对应的统计数组，这样显然无法进行计数排序。

十.排序总结

何为稳定性：

假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的
简单来说：相同值的元素排序前和排序后相对次序保持不变

总结：

稳定的排序算法：冒泡排序，插入排序，归并排序
不稳定的排序算法：选择排序，希尔排序，堆排序，快速排序

---

本文到此结束，码文不易，还请多多支持哦！ 本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/码创造者/article/detail/781486