• 【数据结构】排序（1）

    目录

    一、概念：

    二、直接插入排序：

    三、希尔排序：

    四、直接选择排序：

    五、堆排序：

    六、冒泡排序：

    一、概念：

    排序的概念：

            使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

    排序又分为内部排序和外部排序：

    内部排序：数据元素全部放在内存中的排序。

    外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

    常见的排序算法：

    二、直接插入排序：

    基本思想：

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

    例如在我们玩扑克牌斗地主时的码牌操作中就运用到了这个思想。

    代码实现：

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

    1. //时间复杂度: O(N^2)	逆序
    2. //最好的情况: O(N)	顺序有序
    3. void InsertSort(int* a, int n)
    4. {
    5. 	for (int i = 0; i < n - 1; i++)// i小于n-1是为下面条件做铺垫，防止越界
    6. 	{
    7. 		// 设置end为下标，将其与tmp下标位置的数进行比较，并不断更新end
    8. 		int end = i;
    9. 		int tmp = a[end + 1];// 在单趟排序中，tmp固定
    10.  
    11. 		// 设置数组最小数的条件
    12. 		while (end >= 0)
    13. 		{
    14. 			// 对tmp和end位置数进行比较
    15. 			if (tmp < a[end]) 
    16. 			{
    17. 				// 将end位置数复制在end+1处，本质上是更新去排序后对应的位置
    18. 				a[end + 1] = a[end];
    19. 				end--;// 更新end
    20. 			}
    21. 			else
    22. 			{
    23. 				break;
    24. 			}
    25. 		}
    26. 		// 将tmp数放入对应的位置
    27. 		a[end + 1] = tmp;
    28. 	}
    29. }

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

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

    三、希尔排序：

    又称缩小增量排序 

    基本思想：

    先选定一个整数gap，把待排序文件中所有记录分成gap个组，所有距离为gap的记录分在同一组内，并对每一组内的元素进行排序。

    gap越大，大的值更快调到后面，小的值可以更快的调到前面，越不接近有序。

    gap越小，跳的越慢，但是越接近有序，如果gap == 1，就是直接插入排序。

    代码实现：

    1. void ShellSort(int* a, int Size)
    2. {
    3. 	int gap = Size;
    4. 	// gap > 1时是预排序，目的让他接近有序
    5. 	// gap == 1是直接插入排序，目的是让他有序
    6. 	while (gap > 1)
    7. 	{
    8. 		gap = gap / 3 + 1;//保证最后一次gap是1，就是直接插入排序，但是数列已经非常接近有序了
    9. 						 //gap代表的是有多少组
    10.  
    11. 		// 这里就跟直接插入排序的模板一样
    12. 		for (int i = 0; i < Size - gap; i++)
    13. 		{
    14. 			int end = i;
    15. 			int tmp = a[end + gap];
    16. 			while (end >= 0)
    17. 			{
    18. 				if (tmp < a[end])
    19. 				{
    20. 					a[end + gap] = a[end];
    21. 					end -= gap;
    22. 				}
    23. 				else
    24. 				{
    25. 					break;
    26. 				}
    27. 			}
    28. 			a[end + gap] = tmp;
    29. 		}
    30. 	}
    31. }

    希尔排序的特性总结：

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

    2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，就是直接插入排序。

    3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多。

    4. 时间复杂度(平均)：O(N^1.3)

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

    6. 稳定性：不稳定。

    四、直接选择排序：

    基本思想：

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

    代码实现：

    • 在元素集合a[i]--a[n-1]中选择关键码最大(小)的数据元素
    • 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
    • 在剩余的a[i]--a[n-2]（a[i+1]--a[n-1]）集合中，重复上述步骤，直到集合剩余1个元素
    1. // 时间复杂度: O(N^2)
    2. // 最好的情况: O(N^2) 即使原本就有序，还是要暴力取数
    3. // 空间复杂度: O(1)
    4. void SelectSort(int* a, int Size)// 升序
    5. {
    6. 	//设置下标
    7. 	int begin = 0;
    8. 	while (begin < Size)
    9. 	{
    10. 		int min = begin;
    11. 		// 暴力选数
    12. 		for (int i = begin + 1; i < Size; i++)
    13. 		{
    14. 			if (a[i] < a[min])
    15. 			{
    16. 				min = i;
    17. 			}
    18. 		}
    19.  
    20. 		swap(a[begin], a[min]); //这里的swap使用的是库函数中写好了的，
    21. 								// 使用自己写的注意形参与实参
    22. 		begin++;
    23. 	}
    24. }

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

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

    五、堆排序：

    基本思想：

    利用堆删除思想来进行排序使用向下调整。需要注意的是排升序要建大堆，排降序建小堆。

    代码实现：

    1. // 向下调整:升序建大堆
    2. void AdjustDown(int* a, int size, int parent)
    3. {
    4. 	int child = parent * 2 + 1;
    5.  
    6. 	// 一层层的往下判别
    7. 	while (child < size)
    8. 	{
    9. 		// 在保证不越界的前提下找出数大的子节点
    10. 		if (child + 1 < size && a[child + 1] > a[child])
    11. 		{
    12. 			child++;
    13. 		}
    14.  
    15. 		if (a[child] > a[parent])
    16. 		{
    17. 			swap(a[child], a[parent]);// 这里的swap使用的是库函数中写好了的，
    18.                                       // 使用自己写的注意形参与实参
    19. 			// 更新父，子节点
    20. 			parent = child;
    21. 			child = child * 2 + 1;
    22. 		}
    23. 		else
    24. 		{
    25. 			break;
    26. 		}
    27. 	}
    28. }
    29.  
    30. // 升序
    31. void HeapSort(int* a, int Size)
    32. {
    33. 	// O(N)
    34. 	// 要排升序，所以建大堆->找最后一个分叶节点向下调整，然后向前依次操作
    35. 	for (int i = (Size - 1 - 1) / 2; i >= 0; i--)
    36. 	// Size是个数，要下标所以-1，结合找最后一个分叶结点公式化简
    37. 	{
    38. 		AdjustDown(a, Size, i);
    39. 	}
    40.  
    41. 	// O(N*logN)
    42.  
    43. 	int end = Size - 1;
    44. 	while (end > 0)
    45. 	{
    46.  
    47. 		swap(a[0], a[end]);
    48.  
    49. 		// 在向下调整使用end时，取的值是小于end，默认忽略最后一位,由前Size-1个数进行向下调整
    50. 		AdjustDown(a, end, 0);
    51. 		end--;
    52. 	}
    53. }

    堆排序的特性总结：

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

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

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

    4. 稳定性：不稳定

    六、冒泡排序：

    基本思想：

           两两元素相比，前一个比后一个大就交换，直到将最大/最小（升序/降序）的元素交换到末尾位置。这为一趟；一共进行 n-1 趟这样的交换将可以把所有的元素排序好。

    代码实现：

    1. //时间复杂度: O(N^2)	乱序
    2. //最好的情况: O(N)   有序
    3. void BubbleSort(int* a, int Size)
    4. {
    5. 	// n个数只需排 n - 1 躺即可
    6. 	for (int i = 0; i < Size - 1; i++)
    7. 	{
    8. 		// 设置一个条件，判断一趟排序下来是否有位置交换
    9. 		bool exchange = false;
    10. 		for (int j = 1; j < Size - i; j++)
    11. 		{
    12. 			if (a[j - 1] > a[j])
    13. 			{
    14. 				swap(a[j - 1], a[j]); // 这里的swap使用的是库函数中写好了的，
    15.                                       // 使用自己写的注意形参与实参
    16. 				exchange = true;
    17. 			}
    18. 		}
    19.  
    20. 		// 如果单趟下来并没有数交换位置则说明这个数列本就有序
    21. 		if (exchange = false)
    22. 		{
    23. 			break;
    24. 		}
    25. 	}
    26. }

    冒泡排序的特性总结：

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

  • 相关阅读:
    2023年13个最适合销售电子书的WordPress主题
    Linux进阶-linux内核
    超声波检测（AE）
    【新版】系统架构设计师 - 层次式架构设计理论与实践
    Web核心快速学习之Servlet技术(其一)
    java应用提速(速度与激情)
    SpringCloud微服务介绍+系统架构
    异常解决！前后端交互时，CORS跨域问题的解决过程
    Java中数组参考指南
    踏进字节的那一瞬间，我泪目了，这437天的外包经历值了....
  • 原文地址：https://blog.csdn.net/2302_76142697/article/details/136139341