• 常见排序算法详解

    目录

    排序的相关概念

    排序：

    稳定性：

    内部排序：                                                                        

    外部排序：

    常见的排序：

    常见排序算法的实现

    插入排序：

    基本思想：

    直接插入排序：

    希尔排序（缩小增量排序）：

    选择排序：

    基本思想：

    直接选择排序：

    堆排序：

    交换排序：

    基本思想：

    冒泡排序：

    快速排序：

    Hoare版本：

    挖坑法：

    前后指针法:

    快排递归优化：

    Hoare版本（优化）:

    挖坑法（优化）:

    前后指针（优化）：

    非递归快排：

    归并排序：

    基本思想：

    递归版本：

    非递归版本：

    计数排序：

    基本思想:

    总结

    排序的相关概念

    排序：

    所谓排序，就是使用一定的方法使一段可排序的序列变得有一定的顺序（递增或递减）。

    稳定性：

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

    内部排序：                                                                        

    数据元素全部放在内存中进行排序。

    外部排序：

    数据元素太多，无法同时全部放进内存中进行排序。因此，需要将待排序的数据存储在外存（磁盘）上，排序时再把数据一部分一部分地调入内存中进行排序，在排序过程中需要多次进行内存和外存之间地交换。这种排序方法就称作外部排序。

    常见的排序：

    常见排序算法的实现

    插入排序：

    基本思想：

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

    日常生活中玩扑克牌拼牌时就用到了插入排序。

    直接插入排序：

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

    排序过程如下图所示：

    代码如下：

    1. void InsertSort(int* a, int n)
    2. {
    3. 	assert(a);
    4. 	int i = 0, j = 0;
    5. 	for (i = 1; i < n; i++)//从第二个元素开始，依次与前边的元素比较
    6. 	{
    7. 		int tem = a[i];
    8. 		j = i - 1;
    9. 		while (j >= 0)
    10. 		{
    11. 			if (a[j] > tem)
    12. 			{
    13. 				a[j + 1] = a[j];
    14. 			}
    15. 			else
    16. 			{
    17. 				break;
    18. 			}
    19. 			j--;
    20. 		}
    21. 		a[j + 1] = tem;
    22. 	}
    23. }

    特性总结：

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

    希尔排序（缩小增量排序）：

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

    排序过程如下：

    代码如下：

    1. void ShellSort(int* a, int n)
    2. {
    3. 	assert(a);
    4. 	int gap = n;
    5. 	while (gap > 1)
    6. 	{
    7. 		gap /= 2;
    8.  
    9. 		//一组一组排序
    10. 		/*int i = 0;
    11. 		for (i = 0; i < gap; i++)
    12. 		{
    13. 			int j = 0;
    14. 			for (j = i; j < n - gap; j += gap)//排一组
    15. 			{
    16. 				int front = j;
    17. 				int back = j + gap;
    18. 				int tem = a[back];//记录back位置原始数据
    19. 				while (front >= 0)
    20. 				{
    21. 					if (tem < a[front])
    22. 					{
    23. 						a[back] = a[front];
    24. 						front -= gap;
    25. 						back -= gap;
    26. 					}
    27. 					else
    28. 					{
    29. 						break;
    30. 					}
    31. 				}
    32. 				a[front + gap] = tem;
    33. 			}
    34. 		}*/
    35.  
    36. 		//多组同时排序
    37. 		int j = 0;
    38. 		for (j = 0; j < n - gap; j ++)//多组同时排
    39. 		{
    40. 			int front = j;
    41. 			int back = j + gap;
    42. 			int tem = a[back];//记录back位置原始数据
    43. 			while (front >= 0)
    44. 			{
    45. 				if (tem < a[front])
    46. 				{
    47. 					a[back] = a[front];
    48. 					front -= gap;
    49. 					back -= gap;
    50. 				}
    51. 				else
    52. 				{
    53. 					break;
    54. 				}
    55. 			}
    56. 			a[front + gap] = tem;
    57. 		}
    58. 	}
    59.  
    60. }

    特性总结：

    1. 希尔排序是对直接插入排序的优化。
    2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap = 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。
    3. 时间复杂度：希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，但有一个大致的范围O(N^1.3)~O(N^2)

    4.空间复杂度：O(1)

    选择排序：

    基本思想：

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

    直接选择排序：

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

    排序过程如下：

    代码如下：

    1. void swap(int* p1, int* p2)//交换函数
    2. {
    3. 	int k = *p1;
    4. 	*p1 = *p2;
    5. 	*p2 = k;
    6. }
    7.  
    8. void SelectSort(int* a, int n)
    9. {
    10. 	assert(a);
    11. 	//每次选最小的放前边
    12. 	//int i = 0, j = 0;
    13. 	//int mini = 0;//最小数的下标
    14. 	//for (j = 0; j < n; j++)
    15. 	//{
    16. 	//	mini = j;
    17. 	//	for (i = j + 1; i < n; i++)
    18. 	//	{
    19. 	//		if (a[i] < a[mini])
    20. 	//		{
    21. 	//			mini = i;
    22. 	//		}
    23. 	//	}
    24. 	//	swap(&a[mini], &a[j]);
    25. 	//}
    26.  
    27. 	//优化--一次选出区间中最大的和最小的,分别插入头部和尾部
    28. 	int begin = 0, end = n - 1;
    29. 	while (begin < end)
    30. 	{
    31. 		int maxi = end, mini = begin;//最大最小值的下标
    32. 		int i = begin;
    33. 		for (; i <= end; i++)
    34. 		{
    35. 			if (a[i] < a[mini])
    36. 			{
    37. 				mini = i;
    38. 			}
    39. 			if (a[i] > a[maxi])
    40. 			{
    41. 				maxi = i;
    42. 			}
    43. 		}
    44. 		swap(&a[begin], &a[mini]);
    45. 		if (maxi == begin)//防止原begin位置是最大值，被换到mini位置
    46. 		{
    47. 			maxi = mini;
    48. 		}
    49. 		swap(&a[end], &a[maxi]);
    50. 		begin++;
    51. 		end--;
    52. 	}
    53. }

    特性总结：

    1. 直接选择排序思考非常好理解，但是效率不是很好，实际中很少使用
    2. 时间复杂度：O(N^2)
    3. 空间复杂度：O(1)
    4. 稳定性：不稳定

    堆排序：

    堆排序即利用堆的思想来进行排序，思路如下：
    1. 建堆
    升序：建大堆
    降序：建小堆
    2. 利用堆删除思想来进行排序
    因为堆顶元素一定是最大值（或最小值）每次把堆顶元素与最后一个元素交换，然后把数组尾指针向前移动1，再对新的堆顶元素进行向下调整，重复上述操作，直至数组尾指针指向第一个元素，此时的数组中的数据就是一个有序的序列。

    代码如下：

    1. void swap(int* p1, int* p2)//交换函数
    2. {
    3. 	int k = *p1;
    4. 	*p1 = *p2;
    5. 	*p2 = k;
    6. }
    7.  
    8. //向下调整（建大堆）
    9. void HeapDown(int* a, int parent, int n)
    10. {
    11. 	assert(a);
    12. 	int child = parent * 2 + 1;//左孩子
    13. 	while (child < n)
    14. 	{
    15. 		if (child+1 < n && a[child] < a[child + 1])//找到大的
    16. 		{
    17. 			child += 1;
    18. 		}
    19.  
    20. 		if (a[child] > a[parent])//大的孩子取代父亲
    21. 		{
    22. 			swap(&a[child], &a[parent]);
    23. 			parent = child;
    24. 			child = parent * 2 + 1;
    25. 		}
    26. 		else
    27. 		{
    28. 			break;
    29. 		}
    30. 	}
    31. }
    32.  
    33. //堆排序
    34. void HeapSort(int* a, int n)
    35. {
    36. 	assert(a);
    37. 	int parent = (n - 1 - 1) / 2;
    38. 	//建大堆
    39. 	for (parent; parent >= 0; parent--)
    40. 	{
    41. 		HeapDown(a, parent, n);
    42. 	}
    43.  
    44. 	//排序
    45. 	int end = n - 1;
    46. 	while (end >= 0)
    47. 	{
    48. 		swap(&a[0], &a[end]);//把最大的放最后，从根向下调整
    49. 		HeapDown(a, 0, end);//从根向下调整
    50. 		end--;
    51. 	}
    52.  
    53. }

    特性总结：

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

    交换排序：

    基本思想：

    根据序列中两个元素值的比较结果来决定是否交换这两个元素在序列中的位置，进而达到将值较大的元素向序列的尾部移动，值较小的元素向序列的前部移动的目的。

    冒泡排序：

    两两元素相比，前一个比后一个大就交换，直到将最大的元素交换到末尾位置，这是第一趟排序，第二趟找出第二大的语速放在倒数第二个位置……进行n-1趟排序后，全部数据就是有序的了。

    排序动图如下：

    代码如下：

    1. void swap(int* p1, int* p2)//交换函数
    2. {
    3. 	int k = *p1;
    4. 	*p1 = *p2;
    5. 	*p2 = k;
    6. }
    7.  
    8. //冒泡排序
    9. void BubbleSort(int* a, int n)
    10. {
    11. 	assert(a);
    12. 	int i = 0, j = 0;
    13. 	for (i = 0; i < n - 1; i++)
    14. 	{
    15. 		int flag = 0;//标记是否进行过交换
    16. 		for (j = 1; j < n - i; j++)
    17. 		{
    18. 			if (a[j-1] > a[j])//每次相邻两个交换
    19. 			{
    20. 				/*int k = a[i];
    21. 				a[i] = a[j];
    22. 				a[j] = k;*/
    23. 				swap(&a[j-1], &a[j]);
    24. 				flag++;
    25. 			}
    26. 		}
    27. 		if (flag == 0)
    28. 		{
    29. 			break;
    30. 		}
    31. 	}
    32. }

    特性总结：

    1. 冒泡排序是一种非常容易理解的排序
    2. 时间复杂度：O(N^2)
    3. 空间复杂度：O(1)
    4. 稳定性：稳定

    快速排序：

    快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

    Hoare版本：

    1、选最左边作key，右边先走找到比key小的值

    2、左边后走找到大于key的值

    3、然后交换left和right的值

    4、一直循环重复上述1 2 3步

    5、两者相遇时的位置，与最左边选定的key值交换（因为是让右边先走，保证了最后相遇时，该位置的值一定是小于key的）

    排序过程如下：

    代码如下：

    1. void swap(int* p1, int* p2)//交换函数
    2. {
    3. 	int k = *p1;
    4. 	*p1 = *p2;
    5. 	*p2 = k;
    6. }
    7.  
    8. //Hoare
    9. int PartSort1(int* a, int left, int right)
    10. {
    11. 	int keyi = left;
    12. 	while (left < right)
    13. 	{
    14. 		while (left < right && a[right] >= a[keyi])//找小
    15. 		{
    16. 			right--;
    17. 		}
    18. 		while (left < right && a[left] <= a[keyi])//找大
    19. 		{
    20. 			left++;
    21. 		}
    22. 		swap(&a[left], &a[right]);
    23. 	}
    24. 	swap(&a[keyi], &a[left]);//因为是右边先开始循环，则当left=right时，a[left]一定小于a[keyi]
    25.  
    26. 	return left;
    27. }
    28.  
    29. void QuickSort(int* a, int begin, int end)
    30. {
    31. 	if (begin >= end)
    32. 	{
    33. 		return;
    34. 	}
    35. 	int keyi = PartSort1(a, begin, end);
    36. 	QuickSort(a, begin, keyi - 1);
    37. 	QuickSort(a, keyi + 1, end);
    38.  
    39. }
    挖坑法：

    创建变量key储存最左边值，以最左边为第一个坑位，不断填充坑位，并不断改变坑位的位置，直至左右指针相遇，此时为最后一个坑位，再把key填入。

    代码入下：

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

    代码入下：

    1. void swap(int* p1, int* p2)//交换函数
    2. {
    3. 	int k = *p1;
    4. 	*p1 = *p2;
    5. 	*p2 = k;
    6. }
    7.  
    8. //前后指针
    9. int PartSort3(int* a, int left, int right)
    10. {
    11. 	int keyi = left;
    12. 	int prev = left;
    13. 	int cur = left + 1;//cur找比a[keti]小的就和prev后一个交换位置
    14. 	while (cur <= right)
    15. 	{
    16. 		if (a[cur] < a[keyi])
    17. 		{
    18. 			swap(&a[++prev], &a[cur]);
    19. 		}
    20. 		cur++;
    21. 	}
    22. 	swap(&a[prev], &a[keyi]);
    23. 	return prev;
    24. }
    25.  
    26. void QuickSort(int* a, int begin, int end)
    27. {
    28. 	if (begin >= end)
    29. 	{
    30. 		return;
    31. 	}
    32.  
    33. 	int keyi = PartSort3(a, begin, end);
    34. 	QuickSort(a, begin, keyi - 1);
    35. 	QuickSort(a, keyi + 1, end);
    36. }
    快排递归优化：

    1.三数取中：

    快速排序对于数据是敏感的，如果这个序列是非常无序，杂乱无章的，那么快速排序的效率是非常高的，可是如果数列有序，时间复杂度就会从O(N*logN)变为O(N^2)，相当于冒泡排序了。若每趟排序所选的key都正好是该序列的中间值，即单趟排序结束后key位于序列正中间，那么快速排序的时间复杂度就是O(NlogN)，但是这是理想情况，当我们面对一组极端情况下的序列，就是有序的数组，选择左边作为key值的话，那么就会退化为O(N^2)的复杂度，所以此时我们选择首位置，尾位置，中间位置的数分别作为三数，选出值大小在中间的数，放到最左边，这样选key还是从左边开始，这样优化后，就不会出现选到最大值或最小值的极端情况了。

    2.小区间优化：

    随着递归深度的增加，递归次数以每层2倍的速度增加，这对效率有着很大的影响，当待排序序列的长度分割到一定大小后，继续分割的效率比插入排序要差，此时可以使用插排而不是快排。

    我们可以当划分区间长度小于10的时候，用插入排序对剩下的数进行排序

    Hoare版本（优化）:
    1. void swap(int* p1, int* p2)//交换函数
    2. {
    3. 	int k = *p1;
    4. 	*p1 = *p2;
    5. 	*p2 = k;
    6. }
    7.  
    8. //三数取中
    9. int GetMid(int* a, int left, int right)
    10. {
    11. 	int mid = (left + right) / 2;
    12. 	if (a[left] > a[mid])
    13. 	{
    14. 		if (a[mid] > a[right])
    15. 		{
    16. 			return mid;
    17. 		}
    18. 		else//a[mid]
    19. 		{
    20. 			if (a[left] > a[right])
    21. 			{
    22. 				return right;
    23. 			}
    24. 			else
    25. 			{
    26. 				return left;
    27. 			}
    28. 		}
    29. 	}
    30. 	else//a[left]
    31. 	{
    32. 		if (a[left] > a[right])
    33. 		{
    34. 			return left;
    35. 		}
    36. 		else//a[left]
    37. 		{
    38. 			if (a[mid] > a[right])
    39. 			{
    40. 				return right;
    41. 			}
    42. 			else
    43. 			{
    44. 				return mid;
    45. 			}
    46. 		}
    47. 	}
    48. }
    49.  
    50. int PartSort1(int* a, int left, int right)
    51. {
    52. 	int mid = GetMid(a, left, right);//三数取中
    53. 	swap(&a[mid], &a[left]);
    54.  
    55. 	int keyi = left;
    56. 	while (left < right)
    57. 	{
    58. 		while (left < right && a[right] >= a[keyi])//找小
    59. 		{
    60. 			right--;
    61. 		}
    62. 		while (left < right && a[left] <= a[keyi])//找大
    63. 		{
    64. 			left++;
    65. 		}
    66. 		swap(&a[left], &a[right]);
    67. 	}
    68. 	swap(&a[keyi], &a[left]);//因为是右边先开始循环，则当left=right时，a[left]一定小于a[keyi]
    69.  
    70. 	return left;
    71. }
    72.  
    73. void QuickSort(int* a, int begin, int end)
    74. {
    75. 	if (begin >= end)
    76. 	{
    77. 		return;
    78. 	}
    79. 	if (end - begin + 1 > 10)//小区间优化
    80. 	{
    81. 		int keyi = PartSort1(a, begin, end);
    82. 		QuickSort(a, begin, keyi - 1);
    83. 		QuickSort(a, keyi + 1, end);
    84. 	}
    85. 	else
    86. 	{
    87. 		InsertSort(a + begin, end - begin + 1);//调用直接插入排序
    88. 	}
    89. 	
    90. }
    挖坑法（优化）:
    1. void swap(int* p1, int* p2)//交换函数
    2. {
    3. 	int k = *p1;
    4. 	*p1 = *p2;
    5. 	*p2 = k;
    6. }
    7.  
    8. //三数取中
    9. int GetMid(int* a, int left, int right)
    10. {
    11. 	int mid = (left + right) / 2;
    12. 	if (a[left] > a[mid])
    13. 	{
    14. 		if (a[mid] > a[right])
    15. 		{
    16. 			return mid;
    17. 		}
    18. 		else//a[mid]
    19. 		{
    20. 			if (a[left] > a[right])
    21. 			{
    22. 				return right;
    23. 			}
    24. 			else
    25. 			{
    26. 				return left;
    27. 			}
    28. 		}
    29. 	}
    30. 	else//a[left]
    31. 	{
    32. 		if (a[left] > a[right])
    33. 		{
    34. 			return left;
    35. 		}
    36. 		else//a[left]
    37. 		{
    38. 			if (a[mid] > a[right])
    39. 			{
    40. 				return right;
    41. 			}
    42. 			else
    43. 			{
    44. 				return mid;
    45. 			}
    46. 		}
    47. 	}
    48. }
    49.  
    50. //挖坑法
    51. int PartSort2(int* a, int left, int right)
    52. {
    53. 	int mid = GetMid(a, left, right);
    54. 	swap(&a[mid], &a[left]);
    55.  
    56. 	int key = a[left];
    57. 	int hold = left;//坑位
    58.  
    59. 	while (left < right)
    60. 	{
    61. 		while (left < right && a[right] >= key)
    62. 		{
    63. 			right--;
    64. 		}
    65. 		a[hold] = a[right];
    66. 		hold = right;//更新坑位
    67.  
    68. 		while (left < right && a[left] <= key)
    69. 		{
    70. 			left++;
    71. 		}
    72. 		a[hold] = a[left];
    73. 		hold = left;//更新坑位
    74. 	}
    75. 	a[left] = key;
    76. 	return left;
    77. }
    78.  
    79. void QuickSort(int* a, int begin, int end)
    80. {
    81. 	if (begin >= end)
    82. 	{
    83. 		return;
    84. 	}
    85. 	if (end - begin + 1 > 10)//小区间优化
    86. 	{
    87. 		int keyi = PartSort2(a, begin, end);
    88. 		QuickSort(a, begin, keyi - 1);
    89. 		QuickSort(a, keyi + 1, end);
    90. 	}
    91. 	else
    92. 	{
    93. 		InsertSort(a + begin, end - begin + 1);//调用直接插入排序
    94. 	}
    95. 	
    96. }
    前后指针（优化）：
    1. void swap(int* p1, int* p2)//交换函数
    2. {
    3. 	int k = *p1;
    4. 	*p1 = *p2;
    5. 	*p2 = k;
    6. }
    7.  
    8. int PartSort3(int* a, int left, int right)
    9. {
    10. 	int keyi = left;
    11. 	int prev = left;
    12. 	int cur = left + 1;//cur找比a[keti]小的就和prev后一个交换位置
    13. 	while (cur <= right)
    14. 	{
    15. 		if (a[cur] < a[keyi])
    16. 		{
    17. 			swap(&a[++prev], &a[cur]);
    18. 		}
    19. 		cur++;
    20. 	}
    21. 	swap(&a[prev], &a[keyi]);
    22. 	return prev;
    23. }
    24.  
    25. void QuickSort(int* a, int begin, int end)
    26. {
    27. 	if (begin >= end)
    28. 	{
    29. 		return;
    30. 	}
    31. 	if (end - begin + 1 > 10)//小区间优化
    32. 	{
    33. 		int keyi = PartSort3(a, begin, end);
    34. 		QuickSort(a, begin, keyi - 1);
    35. 		QuickSort(a, keyi + 1, end);
    36. 	}
    37. 	else
    38. 	{
    39. 		InsertSort(a + begin, end - begin + 1);//直接调用插入排序
    40. 	}
    41. 	
    42. }
    非递归快排：

    当数据量较大时，一直递归调用就会一直开辟栈帧，增加栈的消耗，因此我们可以人工创建一个栈结构，代替递归调用开辟新的栈帧。

    关于栈我在栈和队列详解中有详细介绍，在这里就不再过多介绍。

    具体思路如下：

    1. 申请一个栈，将整个数组的起始位置和终点位置入栈，起始位置先进栈。

    2. 利用栈的特性（后进先出），末位置后进栈，所以末位置先出栈。 定义right、left接收的靠近栈顶的两个元素，作为排序序列的始末位置。

    3. 对数组进行一次单趟排序，返回一个下标keyi。

    4. 此时待排序列被分为[left,keyi-1],keyi,[keyi+1,right]三段，再把左右两边区间的始末位置入栈（若该区间合法），要求区间起始位置先进栈。

    5. 重复2、3、4操作直至栈内为空。

    代码如下：

    1. //快速排序（非递归）
    2. void QuickSortNonr(int* a, int n)
    3. {
    4. 	ST st;
    5. 	STInit(&st);
    6. 	//栈储存[0,n-1]区间左右下标，先入右下标，后入左下标
    7. 	STPush(&st, n - 1);
    8. 	STPush(&st, 0);
    9. 	while (!STEmpty(&st))
    10. 	{
    11. 		int left = STTop(&st);
    12. 		STPop(&st);
    13. 		int right = STTop(&st);
    14. 		STPop(&st);
    15.  
    16. 		int keyi = PartSort3(a, left, right);
    17. 		//[left,right]区间分为[left,keyi-1],keyi,[keyi+1,right]
    18. 		if (keyi + 1 < right)//入[keyi+1,right]区间下标
    19. 		{
    20. 			STPush(&st, right);
    21. 			STPush(&st, keyi + 1);
    22. 		}
    23. 		if (keyi - 1 > left)//入[left,keyi-1]区间下标
    24. 		{
    25. 			STPush(&st, keyi - 1);
    26. 			STPush(&st, left);
    27. 		}
    28. 	}
    29. 	STDestroy(&st);
    30. }

    特性总结：

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

    归并排序：

    基本思想：

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

    递归版本：

    1. void MerSort(int* a, int* tem, int left, int right)
    2. {
    3. 	if (left >= right)
    4. 	{
    5. 		return;
    6. 	}
    7. 	//递归划分区间
    8. 	int mid = (left + right) / 2;
    9. 	MerSort(a, tem, left, mid);
    10. 	MerSort(a, tem, mid + 1, right);
    11.  
    12. 	//归并到tem数组
    13. 	int begin1 = left, end1 = mid;
    14. 	int begin2 = mid + 1, end2 = right;
    15. 	int index = begin1;
    16. 	while (begin1 <= end1 && begin2 <= end2)
    17. 	{
    18. 		if (a[begin1] < a[begin2])
    19. 		{
    20. 			tem[index++] = a[begin1++];
    21. 		}
    22. 		else
    23. 		{
    24. 			tem[index++] = a[begin2++];
    25. 		}
    26. 	}
    27.  
    28. 	while (begin1 <= end1)
    29. 	{
    30. 		tem[index++] = a[begin1++];
    31. 	}
    32.  
    33. 	while (begin2 <= end2)
    34. 	{
    35. 		tem[index++] = a[begin2++];
    36. 	}
    37.  
    38. 	//拷贝回原数组---因为每次都要从原数组中归并到tem数组中，因此每次归并完后都要拷贝回原数组
    39. 	memcpy(a + left, tem + left, sizeof(int) * (right - left + 1));
    40. }
    41. //归并排序
    42. void MergeSort(int* a, int n)
    43. {
    44. 	int* tmp = (int*)malloc(sizeof(int) * n);
    45. 	if (tmp == NULL)
    46. 	{
    47. 		perror("malloc fail");
    48. 		exit(-1);
    49. 	}
    50.  
    51. 	MerSort(a, tmp, 0, n - 1);
    52.  
    53. 	free(tmp);
    54. }

    非递归版本：

    与快排类似，当数据量较大时，一直递归调用会增加栈的消耗，因此我们可以考虑改非递归的方法实现。

    归并改非递归时，可以定义一个gap作为每次归并的区间长度，一趟归并后再把gap乘以2，作为新的归并区间长度，继续归并，直至全部归并完成。其关键在于对边界的控制：

    代码如下：

    1. //归并排序(非递归)
    2. void MergeSortNonr(int* a, int n)
    3. {
    4. 	int* tmp = (int*)malloc(sizeof(int) * n);
    5. 	if (tmp == NULL)
    6. 	{
    7. 		perror("malloc fail");
    8. 		exit(-1);
    9. 	}
    10. 	int gap = 1;//每次归并的长度
    11. 	while (gap < n)
    12. 	{
    13. 		int i = 0;
    14. 		for (i = 0; i < n; i += gap * 2)
    15. 		{
    16. 			int begin1 = i, end1 = i + gap - 1;
    17. 			int begin2 = i + gap, end2 = i + gap + gap - 1;
    18. 			if (begin2 >= n || end1 >= n)//要归并的第二个区间不存在，直接退出
    19. 			{
    20. 				//memcpy(tmp + i, a + i, sizeof(int) * (n - i));//把不归并的数据提前拷贝进tmp数组，防止因为a数组没有全部进行归并，tmp数组中存在随机值，
    21. 															  //进而导致后续把tmp数组数据拷贝进a数组时，拷贝随机数据进a数组
    22. 				break;
    23. 			}
    24. 			if (end2 >= n)//要归并的第二个区间，右边越界，重置右区间
    25. 			{
    26. 				end2 = n - 1;
    27. 			}
    28. 			//printf("[%d,%d][%d,%d]", begin1, end1, begin2, end2);//打印每次归并区间
    29.  
    30. 			int index = begin1;
    31. 			while (begin1 <= end1 && begin2 <= end2)
    32. 			{
    33. 				if (a[begin1] < a[begin2])
    34. 				{
    35. 					tmp[index++] = a[begin1++];
    36. 				}
    37. 				else
    38. 				{
    39. 					tmp[index++] = a[begin2++];
    40. 				}
    41. 			}
    42.  
    43. 			while (begin1 <= end1)
    44. 			{
    45. 				tmp[index++] = a[begin1++];
    46. 			}
    47.  
    48. 			while (begin2 <= end2)
    49. 			{
    50. 				tmp[index++] = a[begin2++];
    51. 			}
    52. 			memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));//每次归并完成后，把tmp中数据拷贝进a数组，防止丢失数据
    53. 		}
    54. 		//memcpy(a, tmp, sizeof(int) * n);//一趟归并后再把tmp数组的数据拷贝进a数
    55. 		gap *= 2;
    56. 	}
    57. 	free(tmp);
    58. }

    特性总结：

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

    计数排序：

    基本思想:

    遍历数组，统计数组中每个元素的出现频率，再按顺序放回原数组。

    需要注意的是，由于待排序列不一定是从0开始的且不知道要创建多大的数组进行计数，因此在遍历数组统计频率时，要同时找出最大最小值，每次计数时，用该位置数值减去最小值即为该数对应的下标，用最大值减去最小值再加1就是要创建的计数数组的大小。

    代码如下：

    1. // 计数排序
    2. void CountSort(int* a, int n)
    3. {
    4. 	int min = a[0];
    5. 	int max = a[0];
    6. 	for (int i = 0; i < n; i++)//找最大值和最小值
    7. 	{
    8. 		if (a[i] > max)
    9. 		{
    10. 			max = a[i];
    11. 		}
    12. 		if (a[i] < min)
    13. 		{
    14. 			min = a[i];
    15. 		}
    16. 	}
    17. 	int range = max - min + 1;//最小值到最大值有多少个数（闭区间）
    18. 	int* count = (int*)malloc(sizeof(int) * range);
    19. 	if (count == NULL)
    20. 	{
    21. 		perror("malloc fail");
    22. 		exit(-1);
    23. 	}
    24. 	memset(count, 0, sizeof(int) * range);
    25. 	//每个数减去min就是对应的下标
    26. 	for (int i = 0; i < n; i++)
    27. 	{
    28. 		count[a[i] - min]++;
    29. 	}
    30. 	//重新写入原数组，下标+min就是原始值
    31. 	int i = 0;
    32. 	for (int j = 0; j < range; j++)
    33. 	{
    34. 		while (count[j]--)
    35. 		{
    36. 			a[i++] = j + min;
    37. 		}
    38. 	}
    39. 	free(count);
    40. }

    特性总结：

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

    4. 稳定性：稳定

    总结

  • 相关阅读:
    详细讲解 —— 多线程初阶（一）认识线程（Java EE初阶）
    Python从入门到实践:包的使用
    C++设计模式_10_ Prototype 原型模式（小模式，不太常用）
    Delphi的函数指针传递和调用
    【Spark】scala基础操作（持续更新）
    解决kubernetes node节点flannel网卡始终不能添加成功的问题
    Java并发编程系列34:CountDownLatch使用
    团队如何选择合适的Git分支策略？
    训练和测试的loss不下降，并且精度超低
    软件设计模式系列之二十——备忘录模式
  • 原文地址：https://blog.csdn.net/qq_74190188/article/details/133614452