• 常见的七大排序

    目录

    ​编辑

    一、直接插入排序

    二、希尔排序

    三、直接选择排序

    四、堆排序

    五、冒泡排序

    六、快速排序

    1.Hore版

    2.挖坑法

    3.前后指针法

    4.部分优化

    5.快排的非递归

    七、归并排序

    一、直接插入排序

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

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

    例如：玩扑克时，摸牌就是插入思想的体现

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

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

    1. 元素集合越接近有序，直接插入排序算法的时间效率越高

    2. 时间复杂度：O(N^2)

    3. 空间复杂度：O(1)，它是一种稳定的排序算法

    4. 稳定性：稳定

    1. //插入排序  时间复杂度 O(N^2) 想比冒泡更好
    2. void InsertSort(int* a, int n)
    3. {
    4. 	//将end + 1,插入到[0,end]这个有序数列，使[0,end + 1]有序
    5. 	//最差的情况1 + 2 + 3 + ..... + n - 1 次等差数列
    6. 	//最好的情况N-1
    7. 	for (int i = 0; i < n - 1; i++)
    8. 	{
    9. 		int end = i;
    10. 		int tmp = a[end + 1];
    11. 		while (end >= 0)
    12. 		{
    13. 			if (a[end] > tmp)
    14. 			{
    15. 				a[end + 1] = a[end];
    16. 				end--;
    17. 			}
    18. 			else
    19. 			{
    20. 				break;
    21. 			}
    22. 		}
    23. 		a[end + 1] = tmp;
    24. 	}
    25. }

    二、希尔排序

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

     希尔排序的特性总结：

    1. 希尔排序是对直接插入排序的优化。

    2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就 会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

    3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的 希尔排序的时间复杂度都不固定：

    实际上希尔排序的效率是非常可观的：

    1. //希尔排序 时间复杂度 O(N^1.3)   O(N*log3N)
    2. void ShellSort(int* a, int n)
    3. {
    4. 	//gap 越大数值大的数据移动越快，预排序越快
    5. 	//当 gap == 1 时就是插入排序
    6. 	int gap = n;
    7. 	while (gap > 1)
    8. 	{
    9. 		gap = gap / 3 + 1;// O(log2N，以2为底数的对数)
    10. 		for (int i = 0; i < n - gap; i++)//gap很大时O(N),gap很小时已经很接近有序了接近于O(N)
    11. 		{
    12. 			int end = i;
    13. 			int tmp = a[end + gap];
    14. 			while (end >= 0)
    15. 			{
    16. 				if (a[end] > tmp)
    17. 				{
    18. 					a[end + gap] = a[end];
    19. 					end -= gap;
    20. 				}
    21. 				else
    22. 				{
    23. 					break;
    24. 				}
    25. 			}
    26. 			a[end + gap] = tmp;
    27. 		}
    28. 	}
    29. }

    三、直接选择排序

    思想：每一次都在数组中选出最大（最小）的元素，放在序列的起始位置，直到全部的数据选择完，完成排序。

    选择排序：

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

    可以说直接选择排序的效率是最低的之一。

    接选择排序的特性总结：

    1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用

    2. 时间复杂度：O(N^2)

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

    4. 稳定性：不稳定

    1. //直接选择排序 时间复杂度 o(N^2)
    2. void SelectSort(int* a, int n)
    3. {
    4. 	int begin = 0, end = n - 1;
    5. 	while (begin < end)
    6. 	{
    7. 		int mini = begin, maxi = begin;
    8. 		for (int i = begin; i <= end; i++)
    9. 		{
    10. 			if (a[mini] > a[i])
    11. 			{
    12. 				mini = i;
    13. 			}
    14. 			if (a[maxi] < a[i])
    15. 			{
    16. 				maxi = i;
    17. 			}
    18. 		}
    19. 		Swap(&a[mini], &a[begin]);
    20. 		if (begin == maxi)
    21. 		{
    22. 			maxi = mini;
    23. 		}
    24. 		Swap(&a[maxi], &a[end]);
    25. 		begin++;
    26. 		end--;
    27. 	}
    28. }

    四、堆排序

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

    逻辑结构：二叉树

    物理结构：一维数组

    建大堆图： 

    然后选出堆顶的元素与堆尾的元素交换，然后迭代下去。

    堆排序的特性总结：

    1. 堆排序使用堆来选数，效率就高了很多。

    2. 时间复杂度：O(N*logN)

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

    4. 稳定性：不稳定

    1. //向下调整算法 最多调整高度次 O(logN) 
    2. void AdjuDown(int* a, int n, int root)
    3. {
    4. 	int parent = root;
    5. 	int child = parent * 2 + 1;
    6. 	while (child < n) // 利用孩子的下标判断结束，完全二叉树，左孩子越界，一定是最后一个父亲节点
    7. 	{
    8. 		if ((child + 1) < n && a[child + 1] > a[child]) // 判断条件注意只有左孩子存在的条件
    9. 		{
    10. 			child += 1;
    11. 		}
    12.  
    13. 		if (a[parent] < a[child])
    14. 		{
    15. 			Swap(&a[parent], &a[child]);
    16. 			parent = child;
    17. 			child = parent * 2 + 1;
    18. 		}
    19. 		else
    20. 		{
    21. 			break;
    22. 		}
    23. 	}
    24. }
    25. //堆排序 时间复杂度 O(N*logN)
    26. void heapSort(int* a, int n)
    27. {
    28. 	//建堆 O(N)
    29. 	//运用大堆来进行排序
    30. 	for (int i = (n - 1 - 1) / 2; i > 0; i--)// O(N)
    31. 	{
    32. 		AdjuDown(a, n, i);
    33. 	}
    34.  
    35. 	int end = n - 1;
    36. 	while (end > 0)
    37. 	{
    38. 		Swap(&a[0],&a[end]);
    39. 		AdjuDown(a, end, 0);
    40. 		--end;
    41. 	}
    42. }

    五、冒泡排序

    基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排 序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

    可以说是初学者最熟悉的排序算法，也是知名度最高的排序算法

     冒泡排序的特性总结：

    1. 冒泡排序是一种非常容易理解的排序

    2. 时间复杂度：O(N^2)

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

    4. 稳定性：稳定

    1. //冒泡排序 时间复杂度 o(N^2) 
    2. void BubbleSort(int* a, int n)
    3. {
    4. 	int exchange = 0;
    5. 	for (int j = 0; j < n - 1; ++j)
    6. 	{
    7. 		for (int i = 1; i < n - j; ++i)
    8. 		{
    9. 			if (a[i - 1] < a[i])
    10. 			{
    11. 				int tmp = a[i];
    12. 				a[i] = a[i - 1];
    13. 				a[i - 1] = tmp;
    14.  
    15. 				exchange = 1;
    16. 			}
    17. 		}
    18.  
    19. 		if (exchange == 0)
    20. 		{
    21. 			break;
    22. 		}
    23.  
    24. 		exchange = 0;
    25. 	}
    26. }

    六、快速排序

    时间复杂度：N*logN

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

    1.Hore版

    思路：单趟就调整一个值在正确的位置上去，使这个值左边的都比他小，右边的都比它大

    注：

    选取左边为基准值，必须保证右边先走。（保证最后的相遇点的值比key小）

    注意判断条件，比如等号。

     

     

    1. // Hore版
    2. void QuickSort1(int *a, int begain, int end)
    3. {
    4. 	if (begain >= end)
    5. 	{
    6. 		return;
    7. 	}
    8.  
    9. 	int keyi = begain;
    10. 	int left = begain;
    11. 	int right = end;
    12. 	while (left < right)
    13. 	{
    14. 		while (left < right && a[right] >= a[keyi])// 注意这里的判断条件
    15. 		{
    16. 			right--;
    17. 		}
    18.  
    19. 		while (left < right && a[left] <= a[keyi])
    20. 		{
    21. 			left++;
    22. 		}
    23. 		
    24. 		Swap(&a[left], &a[right]);
    25. 	}
    26. 	Swap(&a[left], &a[keyi]);
    27. 	keyi = left;
    28. 	
    29. 	QuickSort1(a, begain, keyi - 1);
    30. 	QuickSort1(a, keyi + 1, end);
    31. }

    2.挖坑法

    相比Hore版的方法，挖坑法更好理解为什么右边先走

     

     

    1. // 快速排序（挖坑法）
    2. void QuickSort(int* a, int begain, int end)
    3. {
    4. 	if ( begain >= end )
    5. 	{
    6. 		return;
    7. 	}
    8.  
    9. 	int left = begain;
    10. 	int right = end;
    11. 	int key = a[left];
    12. 	int pivot = left;
    13.  
    14. 	while (left < right)
    15. 	{
    16. 		while (left < right && a[right] >= key)
    17. 		{
    18. 			right--;
    19. 		}
    20. 		Swap(&a[pivot], &a[right]);
    21. 		pivot = right;
    22.  
    23. 		while (left < right && a[left] <= key)
    24. 		{
    25. 			left++;
    26. 		}
    27. 		Swap(&a[pivot], &a[left]);
    28. 		pivot = left;
    29. 	}
    30. 	pivot = left;
    31. 	a[pivot] = key;
    32.  
    33. 	QuickSort(a, begain, pivot - 1);
    34. 	QuickSort(a, pivot + 1, end);
    35. }

    3.前后指针法

    定义prev和cur指针，目的将比key小的都调整到前面 

     

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

    4.部分优化

    插入排序小区间优化，当需要递归排序的数小于10时就使用插入排序

     

    1. void QuickSort1(int *a, int begain, int end)
    2. {
    3. 	if (begain >= end)
    4. 	{
    5. 		return;
    6. 	}
    7.  
    8. 	int keyi = begain;
    9. 	int left = begain;
    10. 	int right = end;
    11.  
    12. 	if (end - begain < 10)// 优化如果只有十个数的递归，直接用插入排序更加节省时间
    13. 	{
    14. 		InsertSort(a + begain,  end - begain - 1);
    15. 	}
    16.  
    17. 	while (left < right)
    18. 	{
    19. 		while (left < right && a[right] >= a[keyi])
    20. 		{
    21. 			right--;
    22. 		}
    23.  
    24. 		while (left < right && a[left] <= a[keyi])
    25. 		{
    26. 			left++;
    27. 		}
    28. 		
    29. 		Swap(&a[left], &a[right]);
    30. 	}
    31. 	Swap(&a[left], &a[keyi]);
    32. 	keyi = left;
    33. 	
    34. 	QuickSort1(a, begain, keyi - 1);
    35. 	QuickSort1(a, keyi + 1, end);
    36. }

    三数取中间优化：开头结尾和中间数，取中间的数

     

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

    5.快排的非递归

    为什么要改非递归？

    递归的缺陷：

    1.效率低

    2.如果栈帧太深，栈会不够用，可能会溢出

    1. // 单趟排序
    2. int PartSort(int* a, int left, int right)
    3. {
    4. 	int keyi = left;
    5.  
    6. 	while (left < right)
    7. 	{
    8. 		while (left < right && a[right] >= a[keyi])
    9. 		{
    10. 			right--;
    11. 		}
    12.  
    13. 		while (left < right && a[left] <= a[keyi])
    14. 		{
    15. 			left++;
    16. 		}
    17.  
    18. 		Swap(&a[left], &a[right]);
    19. 	}
    20. 	Swap(&a[left], &a[keyi]);
    21. 	keyi = left;
    22.  
    23. 	return keyi;
    24. }
    25. // 非递归快排
    26. void QuickSortNotR(int* a, int begain, int end)
    27. {
    28. 	ST S;
    29. 	StackInit(&S);
    30. 	StackPush(&S, end);
    31. 	StackPush(&S, begain);
    32.  
    33. 	while (!StackEmpty(&S))// 在堆区模拟递归入栈出栈的过程
    34. 	{
    35. 		int left = StackTop(&S);
    36. 		StackPop(&S);
    37.  
    38. 		int right = StackTop(&S);
    39. 		StackPop(&S);
    40.  
    41. 		int keyi = PartSort(a, left, right);
    42.  
    43. 		if (keyi + 1 < right)// 如果区间大于1就入栈
    44. 		{
    45. 			StackPush(&S, right);
    46. 			StackPush(&S, keyi + 1);
    47. 		}
    48.  
    49. 		if (keyi - 1 > left)// 如果区间大于1就入栈
    50. 		{
    51. 			StackPush(&S, keyi - 1);
    52. 			StackPush(&S, left);
    53. 		}
    54. 	}
    55. }

    总结：

    1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序

    2. 时间复杂度：O(N*logN)

    3. 空间复杂度：O(logN)

    4. 稳定性：不稳定

    七、归并排序

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

    1. void _MergeSort(int* a, int left, int right, int* tmp)
    2. {
    3. 	if (left >= right)
    4. 	{
    5. 		return;
    6. 	}
    7.  
    8. 	int mid = (left + right) >> 1;
    9.  
    10. 	_MergeSort(a, left, mid, tmp);
    11. 	_MergeSort(a, mid + 1, right, tmp);
    12.  
    13. 	// 归并
    14. 	int begain1 = left, end1 = mid;
    15. 	int begain2 = mid + 1, end2 = right;
    16. 	int index = left;
    17.  
    18. 	while (begain1 <= end1 && begain2 <= end2)
    19. 	{
    20. 		if (a[begain1] < a[begain2])
    21. 		{
    22. 			tmp[index++] = a[begain1++];
    23. 		}
    24. 		else
    25. 		{
    26. 			tmp[index++] = a[begain2++];
    27. 		}
    28. 	}
    29.  
    30. 	while (begain1 <= end1)
    31. 	{
    32. 		tmp[index++] = a[begain1++];
    33. 	}
    34.  
    35. 	while (begain2 <= end2)
    36. 	{
    37. 		tmp[index++] = a[begain2++];
    38. 	}
    39.  
    40. 	// 拷贝回去
    41. 	for (int i = 0; i <= right; i++)
    42. 	{
    43. 		a[i] = tmp[i];
    44. 	}
    45. }
    46.  
    47. //归并排序
    48. void MergeSort(int* a, int n)
    49. {
    50. 	int* tmp = (int*)malloc(sizeof(int) * n);
    51. 	_MergeSort(a, 0, n - 1, tmp);
    52. 	free(tmp);
    53. }

    归并的非递归

    1. / 归并非递归
    2. void MergeSortNonR(int* a, int n)
    3. {
    4. 	int* tmp = (int*)malloc(sizeof(int) * n);
    5.  
    6. 	if (tmp == NULL)
    7. 	{
    8. 		exit(-1);
    9. 	}
    10.  
    11. 	int gap = 1;
    12. 	
    13. 	while (gap < n)
    14. 	{
    15. 		for (int i = 0; i < n; i += 2*gap)
    16. 		{
    17. 			// 区间 [i, i+gap-1],[i+gap, i+2*gap-1]
    18.  
    19. 			int begain1 = i, end1 = i + gap - 1;
    20. 			int begain2 = i + gap, end2 = i + 2 * gap - 1;
    21. 			int index = i;
    22.  
    23. 			// 归并时 右区间越界不存在
    24. 			if (begain2 >= n)
    25. 			{
    26. 				break;
    27. 			}
    28.  
    29. 			// 归并时 右区间缺
    30. 			if (end2 >= n)
    31. 			{
    32. 				end2 = n - 1;
    33. 			}
    34.  
    35. 			while (begain1 <= end1 && begain2 <= end2)
    36. 			{
    37. 				if (a[begain1] < a[begain2])
    38. 				{
    39. 					tmp[index++] = a[begain1++];
    40. 				}
    41. 				else
    42. 				{
    43. 					tmp[index++] = a[begain2++];
    44. 				}
    45. 			}
    46.  
    47. 			while (begain1 <= end1)
    48. 			{
    49. 				tmp[index++] = a[begain1++];
    50. 			}
    51.  
    52. 			while (begain2 <= end2)
    53. 			{
    54. 				tmp[index++] = a[begain2++];
    55. 			}
    56.  
    57. 			// 拷贝回去
    58. 			for (int j = 0; j <= end2; j++)
    59. 			{
    60. 				a[j] = tmp[j];
    61. 			}
    62. 		}
    63.  
    64. 		gap *= 2;
    65.  
    66. 	}
    67.  
    68. 	free(tmp);
    69. }

    归并的特性：

    1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。

    2. 时间复杂度：O(N*logN)

    3. 空间复杂度：O(N)

    4. 稳定性：稳定

  • 相关阅读:
    sms deliver解码
    hive变更数据过程
    【见刊通知】ISEEIE 2022 & COMSE 2022已见刊，请自行查看见刊链接 ~
    plyr音视频播放插件使用示例
    Leetcode581. 最短无序连续子数组
    网络安全（6）
    帆软的数知鸟是一个什么东西
    力扣：128. 最长连续序列（Python3）
    Android View绘制基础
    Flink学习第八天——Flink核心的Sink Operator实战
  • 原文地址：https://blog.csdn.net/weixin_63246064/article/details/125167158