常见排序算法流程分析及其实现代码

最新推荐文章于 2022-09-05 17:28:22 发布
最新推荐文章于 2022-09-05 17:28:22 发布
阅读量658 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 排序算法 算法 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44042316/article/details/108291908
版权
排序算法时间复杂度空间复杂度稳定性
直接插入排序O(n2)O(1)稳定
折半插入排序O(n2)O(1)稳定
希尔排序O(n1.3)O(1)不稳定
冒泡排序O(n2)O(1)稳定
快速排序O(nlog2n)O(log2n)不稳定
简单选择排序O(n2)O(1)不稳定
堆排序O(nlog2n)O(1)不稳定
二路归并排序O(nlog2n)O(n)稳定
基数排序O(d(n+rd))O(rd)稳定

一、直接插入排序

1、执行流程

每趟将一个待排序的元素依次与已经比较完并排好序的序列比较并插入到相应的位置，直到所有待排序元素都被插入到有序序列中为止

原始序列：49 38 65 97 76 13 27 49
（序列中有两个49，其中一个加粗加以区分并可以验证该排序算法稳定性）

1）首先看49，直接放入有序序列中

  49   38 65 97 76 13 27 49

2）插入38，38<49，所以38插入49之前

  38 49   65 97 76 13 27 49

3）插入65，65>49，所以不需要移动有序序列

  38 49 65   97 76 13 27 49

4）插入97，97>65，所以不需要移动有序序列

  38 49 65 97  76 13 27 49

5）插入76，76<97，所以97向后移动一位，76继续与65比较，76>65，所以76应该插入在65之后，97之前

  38 49 65 76 97  13 27 49

6）插入13，同理可得

  13 38 49 65 76 97  27 49

7）插入27，同理可得

  13 27 38 49 65 76 97  49

8）插入49，同理可得

  13 27 38 49 49 65 76 97

得出最终结果

2、实现代码
public class InsertSort {

	public static void sort(int num[], int n) {
		int i, j, k, temp;
		for(i = 1; i < n; i++) {
			temp = num[i];
			j = i - 1;
			while(j >= 0 && temp < num[j]) {
				num[j+1] = num[j];
				j--;
			}
			num[j+1] = temp;
			
			System.out.print("第"+i+"趟：");
			for(k = 0; k < num.length; k++) {
				System.out.print(num[k] + " ");
			}
			System.out.println();
			
		}
	}

	public static void main(String[] args) {
		int mynum[] = {49, 38, 65, 97, 76, 13, 27, 49};
		sort(mynum, mynum.length);
	}
}

在这里插入图片描述

3、性能分析

时间复杂度：O(n2)
空间复杂度：O(1)
稳定性：稳定

二、折半插入排序

1、执行流程

在这个排序算法中，我们会设置四个辅助变量：low，high，mid，temp。

low用来标志待插入有序序列中最小的元素的下标
high用来标志待插入有序序列中最大的元素的下标
mid即为low与high之间最中间的元素的下标，计算方法为（low+high）/2向下取整。
temp用来标志待排元素的下标

每趟排序low初始定义为0，high定义为已排好序序列的最大元素的下标，temp定义为high+1，比较下标为mid和下标为temp所在元素的大小

当temp<mid时，high=mid-1，low不变，重新计算mid，继续比较
当temp>mid时，low=mid+1，high不变，重新计算mid，继续比较
当low>high时停止比较，得出待排元素应插入的位置

原始序列：49 38 65 97 76 13 27 49
（序列中有两个49，其中一个加粗加以区分并可以验证该排序算法稳定性）

1）首先看49，直接放入有序序列中

  49   38 65 97 76 13 27 49

2）计算38应插入的位置

low=0；high=0；mid=（0+0）/2=0；temp=38
38<49，high=mid-1=-1，此时low>high，停止比较，即38应插入到49之前

  38 49   65 97 76 13 27 49

3）计算65应插入的位置

low=0；high=1；mid=（0+1）/2=0；temp=65
65>38，low=mid+1=1，low<high，继续比较，mid=（1+1）/2=1
65>49，low=mid+1=2，low>high，停止比较，即65应插入到49之后

  38 49 65  97 76 13 27 49

4）计算97应插入的位置

同理可得

  38 49 65 97  76 13 27 49

5）计算76应插入的位置

low=0；high=3；mid=（0+3）/2=1；temp=76
76>49，low=mid+1=2，mid=（2+3）/2=2
76>65，low=mid+1=3，mid=（3+3）/2=3
76<97，high=mid-1=2，此时low>high，停止比较，即76应插入到97之前

  38 49 65 76 97  13 27 49

剩余比较步骤省略

2、执行代码
public class BinarySort {

	public static void sort(int num[], int n) {
		int i, j, k, low, mid, high, temp;
		for(i = 1; i < n; i++) {
			low = 0;
			high = i - 1;
			temp = num[i];
			while(low <= high) {
				mid = (low + high) / 2;
				if(temp < num[mid]) {
					high = mid - 1;
				}else {
					low = mid + 1;
				}
			}
			for(j = i - 1; j >= high + 1; j--) {
				num[j+1] = num[j];
			}
			num[j+1] = temp;
			System.out.print("第"+i+"趟：");
			for(k = 0; k < num.length; k++) {
				System.out.print(num[k] + " ");
			}
			System.out.println();
		}
	}

	public static void main(String[] args) {
		int mynum[] = {49, 38, 65, 97, 76, 13, 27, 49};
		sort(mynum, mynum.length);
	}
}

在这里插入图片描述

3、性能分析

时间复杂度：O(n2)
空间复杂度：O(1)
稳定性：稳定

三、希尔排序

1、执行流程

原始序列：49 38 65 97 76 13 27 49 55 04
（序列中有两个49，其中一个加粗加以区分并可以验证该排序算法稳定性）

因为原始序列长度为10，所以n=10/2=5，按照n=5的增量划分

49   13
  38   27
    65   49
      97   55
        76   04

每组进行直接插入排序，得到

13   49
  27   38
    49   65
      55   97
        04   76

从而得到序列

13 27 49 55 04 49 38 65 97 76

再次计算n/2，即5/2=3，按照n=3的增量划分

13 55 38 76
  27 04 65
    49 49 97

每组进行直接插入排序，得到

13 38 55 76
  04 27 65
    49 49 97

从而得到序列

13 04 49 38 27 49 55 65 97 76

最后以增量为一进行划分，就相当于最后进行一次直接插入排序，得到最终结果

04 13 27 38 49 49 55 65 76 97

2、执行代码
public class ShellSort {

	public static void sort(int num[], int n) {
		int i, j, k, temp;
		int count = 0;
		while(n > 1) {
			n = n / 2;
			for(i = 0; i < n; i++) {
				for(j = i + n; j < num.length; j = j + n) {
					temp = num[j];
					for(k = j - n; k >= 0 && num[k] > temp; k = k - n) {
						num[k + n] = num[k];
					}
					num[k + n] = temp;
				}
			}
			System.out.print("第"+(++count)+"趟：");
			for(k = 0; k < num.length; k++) {
				System.out.print(num[k] + " ");
			}
			System.out.println();
		}
	}

	public static void main(String[] args) {
		int mynum[] = {49, 38, 65, 97, 76, 13, 27, 49, 55, 4};
		sort(mynum, mynum.length);
	}
}

在这里插入图片描述

3、性能分析

时间复杂度：O(n1.3) — O(n2)
空间复杂度：O(1)
稳定性：不稳定

四、冒泡排序

1、执行流程

首先第一个元素和第二个元素比较，如果第一个元素较大，则交换两者位置，否则不交换；继续比较第二个元素和第三个元素，第三个与第四个元素，直到最大的元素被放在了最后面，一趟冒泡排序完成。经过多趟冒泡排序后，最终的序列即为有序序列

原始序列：49 38 65 97 76 13 27 49
（序列中有两个49，其中一个加粗加以区分并可以验证该排序算法稳定性）

1）第一趟

49>38，交换
38 49 65 97 76 13 27 49

49<65，不交换
38 49 65 97 76 13 27 49

65<97，不交换
38 49 65 97 76 13 27 49

97>76，交换
38 49 65 76 97 13 27 49

97>13，交换
38 49 65 76 13 97 27 49

97>27，交换
38 49 65 76 13 27 97 49

97>49，交换
38 49 65 76 13 27 49 97

至此一趟冒泡排序完成，最大的数97被放在了最后

2）第二趟

38<49，不交换

49<65，不交换

65<76，不交换

76>13，交换
38 49 65 13 76 27 49 97

76>27，交换
38 49 65 13 27 76 49 97

76>49，交换
38 49 65 13 27 49 76 97

至此完成第二趟排序，最大的数76被放在了最后，继续完成后续排序即可得到最终序列

2、执行代码
public class BubbleSort {

	public static void sort(int num[], int n) {
		int i, j, k, flag, temp;
		for(i = n-1; i >= 1; i--) {
			flag = 0;
			for(j = 1; j <= i; j++) {
				if(num[j-1] > num[j]) {
					temp = num[j];
					num[j] = num[j-1];
					num[j-1] = temp;
					flag = 1;
				}
			}
			if(flag == 0) {
				return;
			}
			System.out.print("第"+(n-i)+"趟：");
			for(k = 0; k < num.length; k++) {
				System.out.print(num[k] + " ");
			}
			System.out.println();
		}
	}

	public static void main(String[] args) {
		int mynum[] = {49, 38, 65, 97, 76, 13, 27, 49};
		sort(mynum, mynum.length);	
	}
}

在这里插入图片描述

3、性能分析

时间复杂度：O(n2)
空间复杂度：O(1)
稳定性：稳定

五、快速排序

1、执行流程

每趟排序选择第一个元素作为枢纽，并分别将 i，j 两个变量指向首尾两个元素

首先从 j 开始向前扫描

当 j 所指向的元素小于枢纽值时，将 j 所指向的值赋给 i 所指向的位置，变换扫描方向，由 i 向后扫描
当 i 所指向的元素 大于枢纽值时，将 i 所指向的值赋给 j 所指向的位置，变换扫描方向，由 j 向前扫描
当 i=j 时，枢纽位置最终确定（枢纽前的所有元素均小于枢纽的值，枢纽后的元素均大于枢纽的值），再继续分别对枢纽前后的序列进行排序即可得出最终结果

原始序列：49 38 65 97 76 13 27 49
（序列中有两个49，其中一个加粗加以区分并可以验证该排序算法稳定性）

1）第一趟，将第一个数49作为枢纽，i，j分别指向首尾元素

 49 38 65 97 76 13 27 49
  i          j

j 由后向前扫描，扫描到27时小于枢纽值，27<49，将27放在 i 的位置

 49 38 65 97 76 13 27 49
  i        j

 27 38 65 97 76 13  49
  i        j

变换扫描方向，由 i 向后扫描，扫描到65时大于枢纽值，65>49，将65放在 j 所指向的位置

 27 38 65 97 76 13  49
     i     j

 27 38   97 76 13 65 49
     i     j

变换扫描方向，由 j 向前扫描，扫描到13时小于枢纽值，13<49，将13放在 i 所指向的位置

 27 38   97 76 13 65 49
     i    j

 27 38 13 97 76  65 49
     i    j

变换扫描方向，由 i 向后扫描，扫描到97时大于枢纽值，97>49，将97放在 j 所指向的位置

 27 38 13 97 76   65 49
      i   j

 27 38 13   76 97 65 49
      i   j

变换扫描方向，由 j 向前扫描，当 i=j 时，扫描结束，将49枢纽值放入

 27 38 13   76 97 65 49
      ij

 27 38 13 49 76 97 65 49
      ij

第一趟结束可以看出，ij 所指的49左边均小于49，右边均大于49，再继续对这两个序列进行排序，最终即可得到有序序列

2、执行代码
public class QuickSort {
	
	static int count = 0;
	
	public static void sort(int num[], int low, int high) {
		int temp, k;
		int i = low, j = high;
		if(low < high) {
			temp = num[low];
			while(i < j) {
				while(j > i && num[j] >= temp) {
					j--;
				}
				if(i < j) {
					num[i] = num[j];
					i++;
				}
				while(i < j && num[i] < temp) {
					i++;
				}
				if(i < j) {
					num[j] = num[i];
					j--;
				}
			}
			num[i] = temp;
			count++;
			System.out.print("第"+count+"趟：");
			for(k = 0; k < num.length; k++) {
				System.out.print(num[k] + " ");
			}
			
			System.out.println();
			sort(num, low, i-1);
			sort(num, i+1, high);
		}
	}

	public static void main(String[] args) {
		int mynum[] = {49, 38, 65, 97, 76, 13, 27, 49};
		sort(mynum, 0, mynum.length-1);	
	}
}

在这里插入图片描述

3、性能分析

时间复杂度：O(nlog2n)
空间复杂度：O(log2n)
稳定性：不稳定

六、简单选择排序

1、执行流程

从无序序列中找出最小的元素与其第一个元素交换位置（也可以理解为放入有序序列中）

原始序列：49 38 65 97 76 13 27 49
（序列中有两个49，其中一个加粗加以区分并可以验证该排序算法稳定性）

1）选择出最小的元素13，与无序序列第一一个元素49交换

13  38 65 97 76 49 27 49

2）选择出最小的元素27，与无序序列第一个元素38交换

13 27  65 97 76 49 38 49

3）选择出最小的元素38，与无序序列第一个元素65交换

13 27 38  97 76 49 65 49

以此类推即可得出最终序列

2、执行代码
public class SelectSort {
	
	public static void sort(int num[], int n) {
		int i, j, k, temp;
		for(i = 0; i < n; i++) {
			k = i;
			for(j = i+1; j < n; j++) {
				if(num[k] > num[j]) {
					k = j;
				}
			}
			temp = num[i];
			num[i] = num[k];
			num[k] = temp;
			
			System.out.print("第"+(i+1)+"趟：");
			for(k = 0; k < num.length; k++) {
				System.out.print(num[k] + " ");
			}
			System.out.println();
		}
	}

	public static void main(String[] args) {
		int mynum[] = {49, 38, 65, 97, 76, 13, 27, 49};
		sort(mynum, mynum.length);	
	}
}

在这里插入图片描述

3、性能分析

时间复杂度：O(n2)
空间复杂度：O(1)
稳定性：不稳定

智慧包
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Deep SORT算法流程分析
weixin_40912987的博客
05-29 4054
Deep SORT 基于代码的算法流程分析 1.检测并筛选 １.１从txt中获取当前帧的检测结果。 １.２筛选检测框，只保留检测框的h大于min height，.且 检测框的置信度大于min_ confidence 的。 １.３利用NMS（非极大值抑制）进行筛选，将属于同一个目标的bbox舍去。目的是消除一个目标身上多个框的情况。 原理：将所有bbox按scorce排列，将其他的bbox与最大的bbox进行IOU，大于nms max overlap 则认为是同一个目标，舍去，依次比较。(程序中nms_max
常见排序算法的实现
An_Mo的博客
07-12 275
1、插入排序： 基本思想：直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。 直接插入排序： 当插入第i（i>=1）个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。 直接插入排序
排序算法的实现
weixin_47991674的博客
07-13 215
一、排序算法 （一）冒泡排序 1. Python代码实现 def bubbleSort(arr,n): ''' :param arr: 需要排序的序列 :param n: 降序(True)或者升序(False) :return: 排序后的序列 ''' for i in range(len(arr) - 1): for j in range(len(arr) - 1 - i): if arr[j] <= arr[j + 1
排序算法详解
呵呵彡的博客
03-14 1437
排序算法详解
快速排序的详细执行流程
qq_39839075的博客
02-19 1871
快速排序是一种非常常用的排序算法，由于其平均时间复杂度绝大多数时候是O(logn)，并且是一种原地排序的算法，所以在面对大数据量的排序需求时，是我们的常用选择。 快速排序的基本思想是这样的：从待排序数据集中找到一个pivot(分区点)，之后将小于pivot的数据移动到pivot的左边，将大于pivot的数据移动到pivot的右边。重复该动作，直到pivot左右的数据集大小为1后终止。这个算法最核心的部分是分区点的选择。为了保证原地排序，分区函数不能引入额外空间 先贴一下java代码的实现 class Qui
排序算法matlab仿真代码
07-15
总的来说，掌握排序算法及其MATLAB实现对于提升编程技能和优化数据处理流程至关重要。无论是插入排序、希尔排序还是快速排序，都有其独特的应用场景和性能特征。通过仿真和运算量统计，我们可以更深入地了解这些算法...
使用C语言实现的常见数据结构和算法.zip
最新发布
10-09
这个名为"使用C语言实现的常见数据结构和算法.zip"的压缩包很可能包含了多种常用的数据结构及其相关的算法实现，旨在帮助学习者通过C语言提升自己的编程技能。 数据结构是组织、存储和管理数据的方式，它允许我们...
Leetcode cookbook算法集+源代码.zip
01-06
它包含了大量LeetCode上的经典算法题目及其解决方案，覆盖了各种编程语言，如Java、Python、C++等。LeetCode是一个在线平台，提供了一系列的编程挑战，旨在提升解决实际问题的能力，同时也是许多知名公司招聘过程中...
北京大学算法设计与分析PPT
11-07
PPT可能会介绍各种经典的排序算法，如冒泡排序、插入排序、选择排序、快速排序、归并排序以及堆排序等，同时分析它们的时间复杂度和稳定性。查找算法方面，除了线性查找，二分查找、哈希查找和二叉搜索树等高效查找...
数据结构与算法分析_Java语言及示例.rar
03-12
例如，可能会用图形表示树的遍历过程，或者通过流程图展示排序算法的工作原理。此外，书中应该还会包含实际的代码示例，让读者能够动手实践，加深理解。 文档“数据结构与算法分析_Java语言描述中文.pdf”很可能是...
排序方法分析与代码实现
weixin_43525722的博客
09-28 148
排序也称排序算法(Sort Algorithm)，排序是将一组数据，依指定的顺序进行排列的过程。鉴于经常面试中需要考察本方面的内容，也为了后期及时复习相关知识，故在此将算法相关知识系列进行总结记录，以便学习使用，希望对看到这些文章的你有所帮助。 本系列将从以下两个方面对排序相关知识进行总结整理： 排序的相关概念理解 排序各类算法的分析和代码实现 所以会分为两篇文章进行整理。这里是第一篇，也就是第一部分排序的相关概念理解，废话不多说，咱们直接进入正题。 排序的分类 内部排序: 指将需要处理的所有数据都加载到
排序算法详细讲解（超酷）
热门推荐
qq_51419787的博客
03-30 1万+
排序算法作为数据结构中重要的部分，是必须要掌握的知识之一。 目录 前言 一、插入类排序 1.直接插入排序 2.折半插入排序 3.希尔排序 二、交换类排序 1.冒泡排序（相邻比序法） 2.快速排序 三、选择类排序 1.简单选择排序 2.树形选择排序 3.堆排序 四、归并排序 五、分配类排序 1.多关键字排序 2.链式基数排序 3.计数排序 总结 前言 在进行数据处理时，经常需要对数据进行查找，为了查的更快，通常要求数据有序排列。根据排序时......
各大排序算法过程解析、样例代码、比较总结，看这一篇就够了
Su_Rui_的博客
12-14 409
排序算法 排序是数据处理中经常使用的一种重要运算。如何利用计算机进行排序，特别是高效地进行排序是计算机应用中的重要课题之一。因为其使用较广泛，所以排序算法在很多领域得到相当地重视。所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 排序算法的分类 从计算机诞生至今，不少计算机科学家、数学家发明了各式各样的排序算法，各种排序算法可以按照不同原则加以分类。 内部...
快速排序流程
JiavelFF的博客
11-13 409
快速排序是顾名思义那样是速度快的排序吗？不见得，快速排序的英文名字是什么？Quicksort，简单直接的翻译过来确实快速排序，那么实际中的应用到底快不快呢？因为我是个菜鸟我就不去探讨什么复杂度等等的了，在这里只是介绍一下概念，和代码实现。
十大经典排序算法（过程+图解）
BigData
07-16 3616
目录 关于时间复杂度 1、冒泡排序 2、选择排序 3、插入排序 4、希尔排序 5、归并排序 6、快速排序 7、堆排序 8、计数排序 9、桶排序 10、基数排序 排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序...
三种排序方法的流程总结
快叫我傻蛋
05-06 555
选择排序将要排序的对象分作两部份，一个是已排序的，一个是未排序的，从后端未排序部份选择一个最小值，并放入前端已排序部份的最后一个，例如：排序前：70 80 31 37 10 1 48 60 33 80[1] 80 31 37 10 70 48 60 33 80 选出最小值1[1 10] 31 37 80 70 48 60 33 80
几种常见的排序算法和过程图示
anthony_ju的博客
09-03 2555
手撕几种常见的排序算法 测试函数： @Test public void sort() { int[] arr = {25, 14, 1, 13, 89, 200, 130}; //bubbleSort(arr); //insertSort(arr); //shellSort(arr); //quickS...
【常用排序算法归纳总结】
m0_65485466的博客
09-05 283
常见排序算法归纳总结
八大排序算法原理及实现
Yannick Jiang 的专栏
04-15 6130
原文链接：八大排序算法原理及实现 概述 排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。 当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序。 快速排序：是目前基于比较的内部排序中被认为是最...
大数据分析基础：算法与结构解析
算法伪代码是描述算法流程的一种简化表示，通常在实际编程实现前使用。 2. 数据分析工具多种多样，如SPSSStatistics、Matlab2014b和OFFICEPowerpoint都是常见的工具，但OFFICEPowerpoint并不直接用于数据分析，而是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值