六、排序算法介绍2

已于 2022-12-09 10:32:23 修改
阅读量302 收藏
点赞数
分类专栏： 数据结构 文章标签： 排序算法 算法 数据结构
于 2022-12-08 17:00:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asialyf/article/details/128204430
版权

1、冒泡排序

1.1 基本介绍
  • 冒泡排序（Bubble Sorting） 的基本思想是： 通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值， 若发现逆序则交换， 使值较大的元素逐渐从前移向后部， 就像水底下的气泡一样逐渐向上冒。
  • 优化：因为排序的过程中， 各元素不断接近自己的位置， 如果一趟比较下来没有进行过交换， 就说明序列有序， 因此要在排序过程中设置一个标志 flag 判断元素是否进行过交换。 从而减少不必要的比较。 (这里说的优化， 可以在冒泡排序写好后， 再进行)
1.2 冒泡排序图解
  • 第一趟：
    从数组 arr 第一个元素开始，与其后面一个元素比较大小
    如果 arr[i] > arr[i+1] ，则交换，将大的元素换到后面去
    由于是当前元素与其后面一个元素比较大小，所以只需要执行 arr.length - 1 次循环
  • 第二趟：
    从数组 arr 第一个元素开始，与其后面一个元素比较大小
    由于第一趟排序完成，数组最后一个元素已是最大元素，所以只需要执行 arr.length - 1 - 1 次循环

啥时候完成？下面两个条件满足任意一个即可：
当其中有一趟排序没有元素交换位置时，说明数组已经有序
或：按照上述流程，跑完第 arr.length - 1 趟之后
这样来想：5 个元素的数组，最多只需要跑 4 趟
为什么最多只需要跑 4 趟？因为跑完 4 趟之后，数组第二个元素已经成为了数组第二小的元素，那么数组自然就是有序数组
即数组长度如果为 n ，那么则需要跑 n - 1 趟

1.3 代码实现
public class BubbleSort {

	public static void main(String[] args) {
		int[] arr = {3,9,-1,10,-2};
		bubbleSort(arr);
		System.out.println("排序后:"+Arrays.toString(arr));
	}
	
	/**
	 * 冒泡排序  时间复杂度o(n^2)
	 * @param arr
	 */
	private static void bubbleSort(int[] arr) {
		int temp ;
		for (int i = 0; i < arr.length -1; i++) {
			for (int j = 0; j < arr.length -1 - i; j++) {
				if (arr[j] > arr[j+1]) {
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
	}
}
1.4 优化后的代码实现
public class BubbleSort {

	public static void main(String[] args) {
		int[] arr = {3,9,-1,10,20};
		bubbleSort(arr);
		System.out.println("排序后:"+Arrays.toString(arr));
	}
	
	/**
	 * 冒泡排序  时间复杂度o(n^2)
	 * @param arr
	 */
	private static void bubbleSort(int[] arr) {
		int temp ;
		boolean flag = false;//表示是否进行过交换
		for (int i = 0; i < arr.length -1; i++) {
			for (int j = 0; j < arr.length -1 - i; j++) {
				if (arr[j] > arr[j+1]) {
					flag = true;
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
			System.out.println("第" + (i + 1) + "趟排序后的数组");
	 		System.out.println(Arrays.toString(arr));
			if (!flag) {
				//在一趟排序中，一次交换都没有发生过
				break;
			}else {
				//重置flag!!!, 进行下次判断
				flag = false;
			}
		}
	}
}
1.5 测试冒泡排序性能
public class BubbleSort {

	public static void main(String[] args) {
		
		int[] arr = new int[80000];
		for (int i = 0; i < 80000; i++) {
			arr[i] = (int)(Math.random()*8000000);
		}
		
		Date date1 = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String before = simpleDateFormat.format(date1);
		System.out.println("排序前的时间是=" + before);
		
		bubbleSort(arr);
		
		Date date2 = new Date();
		String after = simpleDateFormat.format(date2);
		System.out.println("排序后的时间是=" + after);
	}
	
	/**
	 * 冒泡排序  时间复杂度o(n^2)
	 * @param arr
	 */
	private static void bubbleSort(int[] arr) {
		int temp ;
		boolean flag = false;//表示是否进行过交换
		for (int i = 0; i < arr.length -1; i++) {
			for (int j = 0; j < arr.length -1 - i; j++) {
				if (arr[j] > arr[j+1]) {
					flag = true;
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
			if (!flag) {
				//在一趟排序中，一次交换都没有发生过
				break;
			}else {
				//重置flag!!!, 进行下次判断
				flag = false;
			}
		}
	}
}

程序运行结果：

排序前的时间是=2022-12-07 08:55:42
排序后的时间是=2022-12-07 08:55:52

2、选择排序

2.1 基本介绍

选择式排序也属于内部排序法， 是从欲排序的数据中， 按指定的规则选出某一元素， 再依规定交换位置后达到排序的目的。

2.2 排序思想

选择排序（select sorting） 也是一种简单的排序方法。 它的基本思想是（n 是数组大小）：

  • 第一次从 arr[0]~arr[n-1]中选取最小值，与 arr[0] 交换
  • 第二次从 arr[1]~arr[n-1]中选取最小值， 与 arr[1] 交换
  • 第三次从 arr[2]~arr[n-1]中选取最小值， 与 arr[2] 交换
  • 第 i 次从 arr[i-1]~arr[n-1]中选取最小值， 与 arr[i-1] 交换
  • 第 n-1 次从 arr[n-2]~arr[n-1]中选取最小值，与 arr[n-2] 交换
  • 总共通过 n-1 次， 得到一个按排序码从小到大排列的有序序列
2.3 排序图解

  • 选择排序流程：
    第一次循环，默认 arr[0] 是最小的元素，将其与 arr[1]~arr[n-1] 进行比较，找到最小的元素，并与 arr[0] 的位置位置
    第二次循环，默认 arr[1] 是最小的元素，将其与 arr[2]~arr[n-1] 进行比较，找到最小的元素，并与 arr[1] 的位置位置
    第 i 次循环，默认 arr[i] 是最小的元素，将其与 arr[i+1]~arr[n-1] 进行比较，找到最小的元素，并与 arr[i] 的位置位置
    直到循环执行 n - 1 次

  • 总结：两层 for 循环

    第一层 for 循环控制走多少趟：for (int i = 0; i < arr.length - 1; i++) {
    从数组第一个元素开始，因为每次都是拿当前元素 arr[j] 和其后一个元素 arr[j+1] 进行比较
    到数组倒数第二个元素结束，将 arr[arr.length - 2] 与 arr[arr.length - 1] 进行比较后，数组就已经是有序数组
    如果数组大小为 n ，那么执行完第 n - 1 趟时，数组就已经是有序数组
    第二层 for 循环控制从第几个元素开始执行选择排序：for (int j = i + 1; j < arr.length; j++)
    每次进入第二层 for 循环时，先假设当前元素 arr[i] 是最小的元素：min = arr[i]; ，并记录最小元素的下标：index = i;
    然后依次和其后面的元素 arr[j] 比较，如果找到比 arr[i] 小的元素，则更新最小值和最小值的索引：min = arr[j]; index = j ;
    在这里插入图片描述
    在这里插入图片描述

2.4 代码实现
  • 一步一步理解选择排序算法
//选择排序
public class SelectSort {

	public static void main(String[] args) {
        
		int[] arr = { 101, 34, 119, 1 };
		selectSort(arr);
        
	}

	// 选择排序
	public static void selectSort(int[] arr) {
        
		// 使用逐步推导的方式来，讲解选择排序
		// 第1轮
		// 原始的数组 ： 101, 34, 119, 1
		// 第一轮排序 : 1, 34, 119, 101
		// 算法 先简单--》 做复杂， 就是可以把一个复杂的算法，拆分成简单的问题-》逐步解决

		// 第1轮
		int minIndex = 0;
		int min = arr[0];
		for (int j = 0 + 1; j < arr.length; j++) {
			if (min > arr[j]) { // 说明假定的最小值，并不是最小
				min = arr[j]; // 重置min
				minIndex = j; // 重置minIndex
			}
		}
		// 将最小值，放在arr[0], 即交换
		if (minIndex != 0) {
			arr[minIndex] = arr[0];
			arr[0] = min;
		}
		System.out.println("第1轮后~~");
		System.out.println(Arrays.toString(arr));// 1, 34, 119, 101

		// 第2轮
		minIndex = 1;
		min = arr[1];
		for (int j = 1 + 1; j < arr.length; j++) {
			if (min > arr[j]) { // 说明假定的最小值，并不是最小
				min = arr[j]; // 重置min
				minIndex = j; // 重置minIndex
			}
		}
		// 将最小值，放在arr[0], 即交换
		if (minIndex != 1) {
			arr[minIndex] = arr[1];
			arr[1] = min;
		}
		System.out.println("第2轮后~~");
		System.out.println(Arrays.toString(arr));// 1, 34, 119, 101

		// 第3轮
		minIndex = 2;
		min = arr[2];
		for (int j = 2 + 1; j < arr.length; j++) {
			if (min > arr[j]) { // 说明假定的最小值，并不是最小
				min = arr[j]; // 重置min
				minIndex = j; // 重置minIndex
			}
		}
		// 将最小值，放在arr[0], 即交换
		if (minIndex != 2) {
			arr[minIndex] = arr[2];
			arr[2] = min;
		}
		System.out.println("第3轮后~~");
		System.out.println(Arrays.toString(arr));// 1, 34, 101, 119
	}

}
  • 编写选择排序
//选择排序
public class SelectSort {

	public static void main(String[] args) {
		int[] arr = { 101, 34, 119, 1 };
		selectSort(arr);
	}

	// 选择排序
	public static void selectSort(int[] arr) {

		// 在推导的过程，我们发现了规律，因此，可以使用for来解决
		// 选择排序时间复杂度是 O(n^2)
		for (int i = 0; i < arr.length - 1; i++) {
			int minIndex = i;
			int min = arr[i];
			for (int j = i + 1; j < arr.length; j++) {
				if (min > arr[j]) { // 说明假定的最小值，并不是最小
					min = arr[j]; // 重置min
					minIndex = j; // 重置minIndex
				}
			}

			// 将最小值，放在arr[0], 即交换
			if (minIndex != i) {
				arr[minIndex] = arr[i];
				arr[i] = min;
			}

			System.out.println("第" + (i + 1) + "轮后~~");
			System.out.println(Arrays.toString(arr));
		}

	}
}
2.5 测试选择排序性能
public class SelectSort {

	public static void main(String[] args) {
		int[] arr = new int[80000];
		for (int i = 0; i < 80000; i++) {
			arr[i] = (int)(Math.random()*8000000);
		}
		
		Date date1 = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String before = simpleDateFormat.format(date1);
		System.out.println("排序前的时间是=" + before);
		
		selectSort(arr);
		
		Date date2 = new Date();
		String after = simpleDateFormat.format(date2);
		System.out.println("排序后的时间是=" + after);
	}

	/**
	 * 选择排序
	 * @param arr
	 */
	private static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			//假定最小的
			int minIndex = i;
			int min = arr[i];
			for (int j = i + 1; j < arr.length; j++) {
				if (min > arr[j]) {
					minIndex = j;
					min = arr[j];
				}
			}
			//开始交换
			if (minIndex != i) {
				arr[minIndex] = arr[i];
				arr[i] = min;
			}
		}
	}
}

程序运行结果：

排序前的时间是=2022-12-07 08:58:09
排序后的时间是=2022-12-07 08:58:10
2.6 总结

由于选择排序算法在最内层的 for 循环中，满足 if (min > arr[j]) { 条件后，只需要记录最小值和最小值在数组中的索引，无需像冒泡排序那样每次都要执行交换操作，所以选择排序算法的执行速度比冒泡排序算法快一些

3、插入排序

3.1基本介绍

插入式排序属于内部排序法，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。

3.2 插入排序法思想
  • 插入排序（Insertion Sorting） 的基本思想是： 把 n 个待排序的元素看成为一个有序表和一个无序表
  • 开始时有序表中只包含一个元素， 无序表中包含有 n-1 个元素， 排序过程中每次从无序表中取出第一个元素， 把它的排序码依次与有序表元素的排序码进行比较， 将它插入到有序表中的适当位置， 使之成为新的有序表
3.3 插入排序图解
3.3.1 插入排序逻辑
  • 将数组分为两个数组，前部分有序数组，后部分是无序数组，我们的目的就是一点一点取出无序数组中的值，将其放到有序数组中去
  • 第一趟：arr[0] 作为有序数组的元素，arr[1] 作为无序数组中第一个元素，将 arr[1] 与 arr[0] 进行比较，目标是将 arr[1] 插入到有序数组中
  • 第二趟：arr[0] 和 arr[1] 作为有序数组的元素，arr[2] 作为无序数组中第一个元素，将 arr[2] 与 arr[0] 和 arr[1] 比较，目标是将 arr[2] 插入到有序数组中
  • 第 i 趟：arr[0]~arr[i] 作为有序数组的元素，arr[i+1] 作为无序数组中第一个元素，将 arr[i+1] 与 arr[0]~arr[i] 比较，目标是将 arr[i+1] 插入到有序数组中
  • 第 n-1 趟：此时有序数组为 arr[0]~arr[n-2] ，无序数组为 arr[n-1] ，将无序数组中最后一个元素插入到有序数组中即可
3.3.2 如何进行插入？
  • 假设有个指针（index），指向无序数组中的第一个元素，即 arr[index] 是无序数组中的第一个元素，我们定义一个变量来存储该值：int insertVal = arr[index];，现在要将其插入到前面的有序数组中
  • 将 index 前移一步，则指向有序数组最后一个元素，我们定义一个新的变量来存储该指针：insertIndex = index - 1; ，即 arr[insertIndex] 是有序数组最后一个元素
  • 我们需要找到一个比 insertVal 小的值，并将 insertVal 插入在该值后面：
    ①如果 insertVal > arr[insertIndex] ，执行插入
    ②如果 insertVal < arr[insertIndex] ，将有序数组后移，腾出插入空间，insertIndex 指针前移，再看看前一个元素满不满足条件，直到找到插入位置
    ③即循环终止条件为找到插入位置，又分为两种情况：
    （1）在有序数组中间找到插入位置
    （2）insertVal 比有序数组中所有的数都小，插入在数组第一个位置（insertIndex = 0 的情况）
3.3.3 总结
  • for 循环控制走多少趟：for(int i = 1; i < arr.length; i++) { ，从数组第一个元素开始到数组最后一个元素结束
  • while 循环不断将指针前移，在有序数组中寻找插入位置，并执行插入：
    while (insertIndex >= 0 && insertVal < arr[insertIndex])
    在这里插入图片描述
3.4 代码实现
3.4.1 插入排序分步实现
public class InsertSort {
	public static void main(String[] args) {
		int[] arr = { 101, 34, 119, 1 };
		insertSort(arr);
	}

	/**
	 * 插入排序
	 * 
	 * @param arr
	 */
	public static void insertSort(int[] arr) {
		// 使用逐步推导的方式来讲解，便利理解
		// 第1轮 {101, 34, 119, 1}; => {34, 101, 119, 1}

		//第1轮
		/**
		 *  定义待插入的数
		 *  说明：
		 *  1. insertIndex >= 0 保证在给insertVal 找插入位置，不越界
		 *  2. insertVal < arr[insertIndex] 待插入的数，还没有找到插入位置
		 *  3. 就需要将 arr[insertIndex] 后移
		 */
		// {101, 34, 119, 1}; => {101,101,119,1}
		int insertVal = arr[1];
		// 即arr[1]前面这个数的下标
		int insertIndex = 1 - 1;

		// 给insertVal找到插入的位置
		while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
			arr[insertIndex + 1] = arr[insertIndex];
			insertIndex--;
		}
		//当退出while循环时，说明插入的位置找到, insertIndex + 1
		arr[insertIndex +1] = insertVal;
		System.out.println("第1轮插入");
		System.out.println(Arrays.toString(arr));
		
		//第2轮  {34, 101, 119, 1} => {34, 101, 119, 1}
		insertVal = arr[2];
		insertIndex = 2 - 1;
		
		while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
			arr[insertIndex + 1] = arr[insertIndex];
			insertIndex--;
		}
		
		arr[insertIndex + 1] = insertVal;
		System.out.println("第2轮插入");
		System.out.println(Arrays.toString(arr));
		
		//第3轮  {34, 101, 119, 1} => {1,34, 101, 119}
		insertVal = arr[3];
		insertIndex = 3-1;
		while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
			arr[insertIndex +1] = arr[insertIndex];
			insertIndex --;
		}
		
		arr[insertIndex + 1] = insertVal;
		System.out.println("第3轮插入");
		System.out.println(Arrays.toString(arr));
	}
}
3.4.2 插入排序最终实现
public class InsertSort {
	public static void main(String[] args) {
		int[] arr = { 101, 34, 119, 1 };
		insertSort(arr);
	}

	/**
	 * 最终实现插入排序
	 * @param arr
	 */
	public static void insertSort(int[] arr) {
		int insertVal = 0;
		int insertIndex = 0;
		for (int i = 1; i < arr.length; i++) {
			//定义待插入的数
			insertVal = arr[i];
			insertIndex = i - 1;
			
			while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
				arr[insertIndex + 1] = arr[insertIndex];
				insertIndex--;
			}
			
			arr[insertIndex + 1] = insertVal;
		}
		System.out.println(Arrays.toString(arr));	
		
	}
}
3.4.3 测试插入排序性能
public class InsertSort {
	public static void main(String[] args) {
		int[] arr = new int[80000];
		for (int i = 0; i < 80000; i++) {
			arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
		}

		Date date1 = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String before = simpleDateFormat.format(date1);
		System.out.println("排序前的时间是=" + before);

		insertSort(arr);

		Date date2 = new Date();
		String after = simpleDateFormat.format(date2);
		System.out.println("排序后的时间是=" + after);
	}

	/**
	 * 最终实现插入排序
	 * @param arr
	 */
	public static void insertSort(int[] arr) {
		int insertVal = 0;
		int insertIndex = 0;
		for (int i = 1; i < arr.length; i++) {
			//定义待插入的数
			insertVal = arr[i];
			insertIndex = i - 1;
			
			while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
				arr[insertIndex + 1] = arr[insertIndex];
				insertIndex--;
			}
			
			arr[insertIndex + 1] = insertVal;
		}
		System.out.println(Arrays.toString(arr));	
		
	}
}

程序运行结果

排序前的时间是=2022-12-09 10:24:14
排序后的时间是=2022-12-09 10:24:16
AsiaLYF
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
十大经典排序算法-归并排序算法详解
qq_35344198的博客
06-19 12万+
一、什么是归并排序 1.概念 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分 序列逐层拆分如下 然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并 创建一个大序列，序列长度为两个小序列长度
常用十大排序算法
热门推荐
qq_51664685的博客
04-26 13万+
列举了常见的十大内部排序算法：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序，计数排序，桶排序。
算法学习总结（2）——温故十大经典排序算法
科技D人生
08-29 5万+
一、什么是排序算法 1.1、排序定义 对一序列对象根据某个关键字进行排序。 1.2、排序术语 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；内排序：所有排序操作都在内存中完成；外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；时间复杂度：一个算法执行所耗费的时间。空间...
程序员那些必须掌握的排序算法(上)
。。。
08-17 8万+
现在的IT行业并不像以前那么好混了，从业人员过多，导致初级程序员过剩，这也间接导致了公司的招聘门槛越来越高，要求程序员掌握的知识也越来越多。 算法也是一个争论了很久的话题，程序员到底该不该掌握算法？不同的人有不同的答案，而事实上，很多公司都对算法有一定的要求，有些公司直接在面试的时候便会要求面试者手写算法题。这就对程序员的技术要求产生了很大的考验，所以面对如今的大环境，我们必须掌握算法，才能在今后...
C语言的5种简单排序算法
Finecsr的博客
04-27 5万+
基本概要： 本文主要介绍五种简单常用的排序算法：冒泡排序，快速排序，插入排序，选择排序，希尔排序，包括它们的基本思想和代码实现。值得一说的是：插入排序，冒泡排序，选择排序平均情况下的时间复杂度为，因此在排序数据较少的情况下较好；而希尔排序和快速排序的平均时间复杂度为，因此在排序数据较多的情况下较好，但是对于快速排序而言，数据基本有序时反而不好，接下来会详细阐述。 1.冒泡排序（Bubble Sort） 基本思想： 冒泡排序是一个非常好理解的排序，顾名思义——冒泡，此时将要排序的数据从上至下排列，从最
【C语言】八大排序算法
weixin_63449996的博客
09-30 1万+
本文详细介绍了数据结构的排序算法，结合动图，基本思想，解析，代码，你也可以手撕算法。
【排序算法】希尔排序（C语言）
weixin_52811588的博客
08-21 5万+
希尔排序也叫缩小增量排序，这里详述了希尔排序的步骤和过程，并用C语言实现了希尔排序，提供给大家参考
十大经典排序算法-快速排序算法详解
qq_35344198的博客
06-16 8万+
一、什么是快速排序 1.概念 快速排序（Quick Sort）是从冒泡排序算法演变而来的，实际上是在冒泡排序基础上的递归分治法。快速排序在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成了两个部分 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照快速排序的思想，我们先选择一个基准元素，进行排序 我们选取4为我们的基准元素，并设置基准元素的位置为index，设置两个指针left和right，分别指向最左
图解快速排序算法
chenchenchencl的博客
08-23 6882
3分钟学会快速排序算法
七大排序算法
yahid的博客
06-28 1万+
排序：排序就是对某项数据按照特定的要求，比如大小或字符长短等按照升序或降序排序。排序过程中设计稳定性，稳定性指的是若有两个相同的数字，比如1和1。如果排序前1在1的前面，排完序后1还在1的前面。那么就说这个排序算法是稳定的，相反则说明不稳定。注意：如果本身就是一个稳定的排序，可以将其变成不稳定排序；如果本身就是不稳定排序，不能变成稳定的排序。常见的排序方法 上面是基于比较的排序。下面一个一个的分析一：直接插入排序 直接插入排序指的是将新的数据插入在已经排好序的序列中。比如我们生活中的玩的斗地主，我们需要将新
数据结构小测试：排序算法
m0_63432840的博客
07-14 429
冒泡排序：将相邻元素之间的比较和交换，使得每一轮比较后，最大的元素能够到达数组的末尾。重复这个过程，直到整个数组有序。选择排序：在每一轮中，找到数组中最小的元素，并将其与当前轮的第一个元素交换位置。重复这一操作，使得每一轮过后，都有一个元素被放到了正确的位置上。插入排序：将数组分为已排序部分和未排序部分，每次从未排序部分取出一个元素，插入到已排序部分的正确位置上。希尔排序：首先确定一个间隔序列，按此间隔将数组元素分组并进行插入排序。随后逐渐缩小间隔并重复排序过程，直到间隔为1。
【C语言】深入解析快速排序
最新发布
Easonmax的博客
07-15 532
快速排序（Quick Sort）是一种基于比较的排序算法。它通过选择一个“基准”元素（pivot），将数组分割成两部分：一部分元素小于基准元素，另一部分元素大于基准元素。然后，递归地对这两部分进行快速排序。快速排序的核心思想是分治法。
大根堆的实现和堆排序
2401_83010439的博客
07-15 432
/建一个大根堆return ans;//插入数据break;
手撕排序算法：选择排序
2303_82176667的博客
07-13 832
选择排序(Selection Sort)是一种简单直观的排序算法。它首先在未排序序列中找到最小(大)元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
【25届秋招备战C++】算法篇-排序算法合集
weixin_44791229的博客
07-12 217
排序算法是计算机科学中的基本算法之一，用于将一组数据按照特定的顺序（升序或降序）进行排列。排序算法广泛应用于数据管理和检索系统，提高数据访问效率，也是其他高级算法的基础，如搜索和合并算法。
从LeetCode215看排序算法
weixin_43562105的博客
07-12 772
2.第二轮比较后，第二大的数字 48 被冒泡到了倒数第二的位置，数组变为：3, 5, 15, 38, 36, 26, 27, 2, 44, 4, 19, 46, 47, 48, 50。1.第一轮比较后，最大的数字 50 被冒泡到了数组末尾，数组变为：3, 5, 38, 15, 44, 36, 26, 27, 2, 46, 4, 19, 47, 48, 50。举个例子，假设我们有一组数字：3, 38, 5, 44, 15, 47, 36, 26, 27, 2, 46, 4, 19, 50, 48。
【八大排序】java版(上)（冒泡、快排、堆排、选择排序）
qq_55846232的博客
07-12 1037
八大排序之 冒泡排序、快速排序、堆排序、选择排序
快排的3种方式
2401_83010439的博客
07-15 434
/（前两种时间复杂度为o(n^2) , 最后一种为o(n*logn）//把一个数组以arr[R]划分，返回的是值为arr[R]的区间。//使数组中以arr[R]划分，返回循环后arr[R]的所在地。
【C语言】深入解析希尔排序
Easonmax的博客
07-15 517
希尔排序（Shell Sort）是由计算机科学家Donald Shell于1959年提出的一种排序算法。它的基本思想是将待排序的数组按照一定的间隔分割成若干子序列，对每个子序列进行插入排序，随着排序进行逐步缩小间隔，最后进行一次普通的插入排序。希尔排序通过消除插入排序在大部分情况下效率低下的缺点，从而提高排序速度。
排序算法（挺全面的）
07-07
排序算法是计算机科学中常用的算法之一，它用于将一组未排序的数据按照某种特定的顺序进行排列。通过排序算法，我们可以更方便地查找、插入、删除或者修改数据。 在我收集的排序算法中，冒泡排序是其中一种广为人知...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值