devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

算法 | 八大排序算法，含动态图详解_各类排序算法动态图

作者：我家自动化 | 2024-07-16 16:29:33

赞

踩

各类排序算法动态图

目录

一.冒泡排序

二.选择排序

三.插入排序

四.希尔排序

五.堆排序

六.快速排序

七.归并排序

 八.基数排序

 九.总结

一.冒泡排序

1.冒泡排序

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

2.算法步骤

  • 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

  • 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

  • 针对所有的元素重复以上的步骤，除了最后一个。

  • 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

3.稳定性：稳定

4.时间复杂度：O(n^2)（平均时间复杂度）

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

6.动态图演示：

7.code

  1. void BubbleSort(int *arr,int len)//len代表要排序数组的长度
  2. {
  3.     for(int i=0;i<len-1;i++)
  4.     {
  5.         int flag=0;
  6.         for(int j=0;j<len-1-i;j++)
  7.         {
  8.             if(arr[j]>arr[j+1]
  9.             {
  10.                 int tmp = arr[j];
  11.                 arr[j]=arr[j+1];
  12.                 arr[j+1]=tmp;
  13.                 flag=1;
  14.             }
  15.         }
  16.         
  17.         if(flag == 0)
  18.         {
  19.             break;
  20.         }
  21.     }
  22. }

二.选择排序

1.选择排序

第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。

2.算法步骤

  • 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

  • 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

  • 重复第二步，直到所有元素均排序完毕。

3.稳定性：不稳定

4.时间复杂度：O(n^2)（平均时间复杂度）

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

6.动态图演示：

7.code:

  1. void SelectSort(int *arr,int len)
  2. {
  3.     for(int i=0;i<len-1;++i)
  4.     {
  5.         int min = i;
  6.         for(int j=i+1;j<len;++j)
  7.         {
  8.             if(arr[j]<arr[min])
  9.             {
  10.                 min=j;
  11.             }
  12.         }
  13.         int tmp = arr[min];
  14.         arr[min]=arr[i];
  15.         arr[i]=tmp;
  16.     }
  17. }

三.插入排序

1.插入排序

每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

2.算法步骤

  • 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

3.稳定性：稳定

4.时间复杂度：O(n^2)（平均时间复杂度）

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

6.动态图演示：

7.code:

  1. void InsertSort(int *arr,int len)
  2. {
  3.     int i;
  4.     int j;
  5.     for(int i=1;i<len;++i)
  6.     {
  7.         int tmp = arr[i];
  8.         for(j =i-1;j>=0 && arr[j]>tmp;--j)
  9.         {
  10.             arr[j+1] = arr[j];
  11.         }
  12.         arr[j+1] = tmp;
  13.     }
  14. }

四.希尔排序

1.希尔排序

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是基于插入排序的以下两点性质而提出改进方法的：

  • 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
  • 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；

希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。

2.算法步骤

  • 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；

  • 按增量序列个数 k，对序列进行 k 趟排序；

  • 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

  • 注意：最后一个增量必须为1

3.稳定性：不稳定

4.时间复杂度：O(nlog n)（平均时间复杂度）

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

6.动态图演示:

数据结构排序算法之希尔排序演示_哔哩哔哩_bilibili

7.code

  1. void ShellSort(int* arr, int len)
  2. {
  3. 	int i;
  4. 	int j;
  5. 	int temp;
  6. 	int gap = len / 2;
  7. 	
  8.  
  9. 	while (gap > 0)
  10. 	{
  11. 		for (i = gap; i < len; i++)
  12. 		{
  13. 			temp = arr[i];
  14. 			for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap)
  15. 			{
  16. 				arr[j + gap] = arr[j];
  17. 			}
  18. 			arr[j + gap] = temp;
  19. 		}
  20. 		gap /= 2;
  21. 	}
  22. }

五.堆排序

1.堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：

  • 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
  • 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；

2.算法步骤

  1. 创建一个堆 H[0……n-1]；

  2. 把堆首（最大值）和堆尾互换；

  3. 把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；

  4. 重复步骤 2，直到堆的尺寸为 1。

3.稳定性：不稳定

4.时间复杂度：O(nlogn)（平均时间复杂度）

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

6.动态图演示：

7.code

  1. void OneAdjust(int *arr,int len,int root)
  2. {
  3. 	int i = root;
  4. 	int tmp = arr[i];//此时的tmp的值为此时根节点的值
  5. 	int j = 2 * i + 1;//左孩子
  6. 	while (j < len)
  7. 	{
  8. 		if (j + 1 < len && arr[j] < arr[j + 1])
  9. 		{
  10. 			j = j + 1;
  11. 		}
  12. 		//此时j就是左右孩子中较大的那一个
  13. 		if (arr[j] > tmp)
  14. 		{
  15. 			arr[i] = arr[j];//形成大堆根
  16. 			i = j;//下一个子树的根
  17. 			j = 2 * i + 1;//下一个子树的左孩子
  18. 		}
  19. 		else
  20. 		{
  21. 			break;
  22. 		}
  23. 	}
  24. 	arr[i] = tmp;
  25. }
  26. void CreateHeap(int* arr, int len)//创建堆
  27. {
  28. 	int root = len / 2 - 1;//最后一个叶子节点的父节点
  29. 	for (; root >= 0; root--)
  30. 	{
  31. 		OneAdjust(arr, len, root);
  32. 	}
  33. }
  34.  
  35. void HeapSort(int* arr, int len)
  36. {
  37. 	int t;
  38. 	CreateHeap(arr, len);
  39. 	for (int i = 0; i < len - 1; i++)
  40. 	{
  41. 		t = arr[0];
  42. 		arr[0] = arr[len - 1 - i];
  43. 		arr[len - 1 - i] = t;
  44. 		OneAdjust(arr, len - i - 1, 0);
  45. 	}
  46. }

六.快速排序

1.快速排序

它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

2.算法步骤

  1. 从数列中挑出一个元素，称为 "基准"（pivot）;

  2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

  3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

3.稳定性：不稳定

4.时间复杂度：O(nlogn)（平均时间复杂度）

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

6.动态图演示：

数据结构排序算法之快速排序演示_哔哩哔哩_bilibili

7.code

  1. void QuickSort(int* a, int left, int right)
  2. //left是最左边的下标
  3. //right是最右边的下标
  4. {
  5.     if (left >=right)
  6. 	{
  7. 		return;
  8. 	}
  9. 	int i = left;
  10. 	int j = right;
  11. 	int temp = a[left];//基准数
  12. 	//排除特殊情况
  13. 	while (i != j)
  14. 	{
  15. 		while (a[j] >= temp && i < j)
  16. 		{
  17. 			j--;//继续向右寻找比基准数小的数，直到找到为止，或者i与j相遇
  18. 		}
  19. 		while (a[i] <= temp && i < j)
  20. 		{
  21. 			i++;//继续向右寻找比基准数大的数，直到找到为止，或者i与j相遇
  22. 		}
  23. 		if (i < j)//此时小于和大于基准数都已被找到，且i与j没有相遇
  24. 		{
  25. 			int t = a[i];
  26. 			a[i] = a[j];
  27. 			a[j] = t;
  28. 		}
  29. 	}
  30. 	//此时i已经与j相遇，
  31. 	a[left] = a[i];//将相遇位置的那个数放到最左边
  32. 	a[i] = temp;//将基准数放到最中间，即相遇的位置
  33. 	//此时基准数将数组分割为两组，基准数之前的数都小于它，后边的都大于它
  34.  
  35. 	//然后分别对基准数两侧的两组数再次进行快排
  36. 	QuickSort(a,left, i - 1);
  37. 	QuickSort(a,i + 1, right);
  38. }

七.归并排序

1.归并排序

归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：

  • 自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；
  • 自下而上的迭代；

 2.算法步骤

  1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；

  2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置；

  3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

  4. 重复步骤 3 直到某一指针达到序列尾；

  5. 将另一序列剩下的所有元素直接复制到合并序列尾。

3.稳定性：稳定

4.时间复杂度：O(nlogn)（平均时间复杂度）

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

6.动态图演示：

7.code

  1. void Meger(int* arr, int left,int right)
  2. {
  3. 		int* temp = (int*)malloc(sizeof(int) *(right-left+1));
  4. 		int middle = (right+left) / 2;
  5. 		int i = left;
  6. 		int j = middle + 1;
  7. 		int t = 0;
  8. 		while (i <= middle && j <=right)
  9. 		{
  10. 			if (arr[i] <= arr[j])		temp[t++] = arr[i++];
  11. 			else
  12. 			{
  13. 				temp[t++] = arr[j++];
  14. 			}
  15. 		}
  16. 		while (i <= middle)
  17. 		{
  18. 			temp[t++] = arr[i++];
  19. 		}
  20. 		while (j <= right)
  21. 		{
  22. 			temp[t++] = arr[j++];
  23. 		}
  24. 		for (i = 0; i < t; i++)
  25. 		{
  26. 			arr[left+i] = temp[i];
  27. 		}
  28. 		free(temp);
  29. }
  30.  
  31. void MegerSort(int* arr, int left,int right)
  32. {
  33. 	if (left<right)
  34. 	{
  35. 		int middle = (left+right) / 2;
  36. 		MegerSort(arr,left,middle);
  37. 		MegerSort(arr, middle + 1, right);
  38. 		Meger(arr, left, right);
  39. 	}
  40. }

 八.基数排序

1.基数排序

基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。

2.算法步骤

  1. 创建队列
  2. 先求最大数字的位数
  3. 求出相应位数的值， 并根据位数值将其存储相应的队列中
  4. 按顺序输出所有队列中的值，  循环处理3,4步，循环次数由第一步算出

3.稳定性： 稳定

4.时间复杂度：O(n x k)（平均时间复杂度）

5.空间复杂度：O(n+k)

6.动态图演示：

7.code

  1. void RadixSort(int *arr, int len)
  2. {
  3. 	queue que[10];
  4. 	for (int i = 0; i < 10; ++i)
  5. 	{
  6. 		que[i].data = (int*)malloc(sizeof(int)* len);
  7. 		assert(que[i].data != NULL);
  8. 		que[i].head = que[i].tail = 0;
  9. 	}
  10.  
  11. 	int width = GetMaxWidth(arr, len); // O(n)
  12.  
  13. 	for (int i = 0; i < width; ++i)  // O(d * n)
  14. 	{
  15. 		//  将数组中所有的数字取其相应位数的值，并将其存储到相应的队列中
  16. 		for (int j = 0; j < len; ++j)
  17. 		{
  18. 			int  num = GetNumOfWidth(arr[j], i);
  19. 			que[num].data[que[num].tail++] = arr[j];
  20. 		}
  21.  
  22. 		int k = 0;
  23. 		for (int m = 0; m < 10; ++m)
  24. 		{
  25. 			while (que[m].head != que[m].tail)
  26. 			{
  27. 				arr[k++] = que[m].data[que[m].head++];
  28. 			}
  29. 		}
  30.  
  31. 		for (int n = 0; n < 10; ++n)
  32. 		{
  33. 			que[n].head = que[n].tail = 0;
  34. 		}
  35. 	}
  36.  
  37. 	for (int i = 0; i < 10; ++i)
  38. 	{
  39. 		free(que[i].data);
  40. 	}
  41. }

8.基数排序 vs 计数排序 vs 桶排序

基数排序有两种方法：

这三种排序算法都利用了桶的概念，但对桶的使用方法上有明显差异：

  • 基数排序：根据键值的每位数字来分配桶；
  • 计数排序：每个桶只存储单一键值；
  • 桶排序：每个桶存储一定范围的数值；

 九.总结

参考博客：1.0 十大经典排序算法 | 菜鸟教程

 注意：本文没有讲述红框中的两个排序算法。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/835232?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号