排序算法（冒泡、选择、插入、希尔、快速、归并、基数）

最新推荐文章于 2022-04-03 19:21:27 发布
最新推荐文章于 2022-04-03 19:21:27 发布
阅读量201 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zeroheitao/article/details/116719270
版权

文章目录

本文排序默认从小到大。

一、冒泡排序

冒泡排序（气泡分类）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

优化：
因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志标志判断元素是否进行过交换。从而减少不必要的比较。

图解例子：
在这里插入图片描述
小结上面的图解过程：

  1. 一共进行数组的大小 -1 次大的循环
  2. 每一趟排序的次数在逐渐的减少
  3. 如果我们发现在某趟排序中，没有发生一次交换，可以提前结束冒泡排序。这个就是优化

实例： 给 80000 个的随机的数组排序。

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); //生成一个[0, 8000000) 数
		}
		
		Date data1 = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String date1Str = simpleDateFormat.format(data1);
		System.out.println("排序前的时间是=" + date1Str);
		
		//测试冒泡排序
		bubbleSort(arr);
		
		Date data2 = new Date();
		String date2Str = simpleDateFormat.format(data2);
		System.out.println("排序后的时间是=" + date2Str);
		
	}
	
	// 将前面冒泡排序算法，封装成一个方法
	public static void bubbleSort(int[] arr) {
		// 冒泡排序 的时间复杂度 O(n^2)
		int temp = 0; // 临时变量
		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 = false; // 重置flag!!!, 进行下次判断
			}
		}
	}

}

二、选择排序

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

排序思想：
选择排序（select sorting）也是一种简单的排序方法。它的基本思想是：第一次从 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 次，得到一个按排序码从小到大排列的有序序列。

实例： 给 80000 个的随机的数组排序。

public class SelectSort {

	public static void main(String[] args) {
		
		//创建要给80000个的随机的数组
		int[] arr = new int[80000];
		for (int i = 0; i < 80000; i++) {
			arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
		}
		
		System.out.println("排序前");
		//System.out.println(Arrays.toString(arr));
		
		Date data1 = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String date1Str = simpleDateFormat.format(data1);
		System.out.println("排序前的时间是=" + date1Str);
		
		selectSort(arr);
		
		
		Date data2 = new Date();
		String date2Str = simpleDateFormat.format(data2);
		System.out.println("排序前的时间是=" + date2Str);
		
		//System.out.println("排序后");
		//System.out.println(Arrays.toString(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));// 1, 34, 119, 101
		}
		
	}

}

三、插入排序

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

插入排序法思想：
插入排序（Insertion Sorting）的基本思想是：把 n 个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有 n-1 个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。
在这里插入图片描述
实例： 给 80000 个的随机的数组排序。

public class InsertSort {

	public static void main(String[] args) {
		
		// 创建要给80000个的随机的数组
		int[] arr = new int[80000];
		for (int i = 0; i < 80000; i++) {
			arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
		}

		System.out.println("插入排序前");
		Date data1 = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String date1Str = simpleDateFormat.format(data1);
		System.out.println("排序前的时间是=" + date1Str);
		
		insertSort(arr); //调用插入排序算法
		
		Date data2 = new Date();
		String date2Str = simpleDateFormat.format(data2);
		System.out.println("排序前的时间是=" + date2Str);
		
		//System.out.println(Arrays.toString(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; // 即arr[i]的前面这个数的下标
	
			// 给insertVal 找到插入的位置
			// 说明
			// 1. insertIndex >= 0 保证在给insertVal 找插入位置，不越界
			// 2. insertVal < arr[insertIndex] 待插入的数，还没有找到插入位置
			// 3. 就需要将 arr[insertIndex] 后移
			while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
				arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]
				insertIndex--;
			}
			// 当退出while循环时，说明插入的位置找到, insertIndex + 1

			//这里我们判断是否需要赋值
			if(insertIndex + 1 != i) {
				arr[insertIndex + 1] = insertVal;
			}
	
			//System.out.println("第"+i+"轮插入");
			//System.out.println(Arrays.toString(arr));
		}
		
	}

}

简单插入算法存在的问题： 当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响。例如：
在这里插入图片描述

四、希尔排序

希尔排序是希尔（Donald Shell）于 1959 年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。

希尔排序法基本思想：
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序：随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止。

在这里插入图片描述
在这里插入图片描述
实例： 给 80000 个的随机的数组排序。（交换法和移动法，移动法能明显缩短排序时间）

public class ShellSort {

	public static void main(String[] args) {
		
		// 创建要给80000个的随机的数组
		int[] arr = new int[80000];
		for (int i = 0; i < 80000; i++) {
			arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
		}

		System.out.println("排序前");
		Date data1 = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String date1Str = simpleDateFormat.format(data1);
		System.out.println("排序前的时间是=" + date1Str);
		
		shellSort(arr); //交换式
		shellSort2(arr);//移位方式
		
		Date data2 = new Date();
		String date2Str = simpleDateFormat.format(data2);
		System.out.println("排序前的时间是=" + date2Str);
		
		//System.out.println(Arrays.toString(arr));
	}

	// 希尔排序时， 对有序序列在插入时采用交换法, 
	public static void shellSort(int[] arr) {
		
		int temp = 0;
		int count = 0;

		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
			for (int i = gap; i < arr.length; i++) {
				// 遍历各组中所有的元素(共gap组), 步长gap
				for (int j = i - gap; j >= 0; j -= gap) {
					// 如果当前元素大于加上步长后的那个元素，说明交换
					if (arr[j] > arr[j + gap]) {
						temp = arr[j];
						arr[j] = arr[j + gap];
						arr[j + gap] = temp;
					}
				}
			}
			//System.out.println("希尔排序第" + (++count) + "轮 =" + Arrays.toString(arr));
		}
		
	}
	
	//对交换式的希尔排序进行优化->移位法
	public static void shellSort2(int[] arr) {
		
		// 增量gap, 并逐步的缩小增量
		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
			// 从第gap个元素，逐个对其所在的组进行直接插入排序
			for (int i = gap; i < arr.length; i++) {
				int j = i;
				int temp = arr[j];
				if (arr[j] < arr[j - gap]) {
					while (j - gap >= 0 && temp < arr[j - gap]) {
						//移动
						arr[j] = arr[j-gap];
						j -= gap;
					}
					//当退出while后，就给temp找到插入的位置
					arr[j] = temp;
				}
			}
		}
	}
}

五、快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
在这里插入图片描述
在这里插入图片描述
实例： 给 80000 个的随机的数组排序。

public class QuickSort {

	public static void main(String[] args) {
		
		//测试快排的执行速度
		// 创建要给80000个的随机的数组
		int[] arr = new int[80000];
		for (int i = 0; i < 80000; i++) {
			arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
		}
		
		System.out.println("排序前");
		Date data1 = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String date1Str = simpleDateFormat.format(data1);
		System.out.println("排序前的时间是=" + date1Str);
		
		quickSort(arr, 0, arr.length-1);
		
		Date data2 = new Date();
		String date2Str = simpleDateFormat.format(data2);
		System.out.println("排序前的时间是=" + date2Str);
		//System.out.println("arr=" + Arrays.toString(arr));
	}

	public static void quickSort(int[] arr,int left, int right) {
		int l = left; //左下标
		int r = right; //右下标
		//pivot 中轴值
		int pivot = arr[(left + right) / 2];
		int temp = 0; //临时变量，作为交换时使用
		//while循环的目的是让比pivot 值小放到左边
		//比pivot 值大放到右边
		while( l < r) { 
			//在pivot的左边一直找,找到大于等于pivot值,才退出
			while( arr[l] < pivot) {
				l += 1;
			}
			//在pivot的右边一直找,找到小于等于pivot值,才退出
			while(arr[r] > pivot) {
				r -= 1;
			}
			//如果l >= r说明pivot 的左右两的值，已经按照左边全部是
			//小于等于pivot值，右边全部是大于等于pivot值
			if( l >= r) {
				break;
			}
			
			//交换
			temp = arr[l];
			arr[l] = arr[r];
			arr[r] = temp;
			
			//如果交换完后，发现这个arr[l] == pivot值 相等 r--， 前移
			if(arr[l] == pivot) {
				r -= 1;
			}
			//如果交换完后，发现这个arr[r] == pivot值 相等 l++， 后移
			if(arr[r] == pivot) {
				l += 1;
			}
		}
		
		// 如果 l == r, 必须l++, r--, 否则为出现栈溢出
		if (l == r) {
			l += 1;
			r -= 1;
		}
		//向左递归
		if(left < r) {
			quickSort(arr, left, r);
		}
		//向右递归
		if(right > l) {
			quickSort(arr, l, right);
		}	
	}
}

六、归并排序

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分 (divide) 成一些小的问题然后递归求解，而治 (conquer) 的阶段则将分的阶段得到的各答案“修补”在一起，即分而治之)。

思想示意图：

1、基本思想：
在这里插入图片描述
2、合并相邻有序子序列：

我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将 [4，5，7，8] 和 [1，2，3，6] 两个已经有序的子序列，合并为最终序列 [1，2，3，4，5，6，7，8]，来看下实现步骤：
在这里插入图片描述
实例： 给 80000 个的随机的数组排序。

public class MergetSort {

	public static void main(String[] args) {
		//int arr[] = { 8, 4, 5, 7, 1, 3, 6, 2 }; //需要合并 arr.length-1 次
		
		//测试快排的执行速度
		// 创建要给80000个的随机的数组
		int[] arr = new int[8000000];
		for (int i = 0; i < 8000000; i++) {
			arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
		}
		System.out.println("排序前");
		Date data1 = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String date1Str = simpleDateFormat.format(data1);
		System.out.println("排序前的时间是=" + date1Str);
		
		int temp[] = new int[arr.length]; //归并排序需要一个额外空间
 		mergeSort(arr, 0, arr.length - 1, temp);
 		
 		Date data2 = new Date();
		String date2Str = simpleDateFormat.format(data2);
		System.out.println("排序前的时间是=" + date2Str);
 		
 		//System.out.println("归并排序后=" + Arrays.toString(arr));
	}
	
	
	//分+合方法
	
	//分
	public static void mergeSort(int[] arr, int left, int right, int[] temp) {
		if(left < right) {
			int mid = (left + right) / 2; //中间索引
			//向左递归进行分解
			mergeSort(arr, left, mid, temp);
			//向右递归进行分解
			mergeSort(arr, mid + 1, right, temp);
			//合并
			merge(arr, left, mid, right, temp);
			
		}
	}
	
	//合并的方法
	/**
	 * 
	 * @param arr 排序的原始数组
	 * @param left 左边有序序列的初始索引
	 * @param mid 中间索引
	 * @param right 右边索引
	 * @param temp 做中转的数组
	 */
	public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
		
		int i = left; // 初始化i, 左边有序序列的初始索引
		int j = mid + 1; //初始化j, 右边有序序列的初始索引
		int t = 0; // 指向temp数组的当前索引
		
		//(一)
		//先把左右两边(有序)的数据按照规则填充到temp数组
		//直到左右两边的有序序列，有一边处理完毕为止
		while (i <= mid && j <= right) {//继续
			//如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素
			//即将左边的当前元素，填充到 temp数组 
			//然后 t++, i++
			if(arr[i] <= arr[j]) {
				temp[t] = arr[i];
				t += 1;
				i += 1;
			} else { //反之,将右边有序序列的当前元素，填充到temp数组
				temp[t] = arr[j];
				t += 1;
				j += 1;
			}
		}
		
		//(二)
		//把有剩余数据的一边的数据依次全部填充到temp
		while( i <= mid) { //左边的有序序列还有剩余的元素，就全部填充到temp
			temp[t] = arr[i];
			t += 1;
			i += 1;	
		}
		
		while( j <= right) { //右边的有序序列还有剩余的元素，就全部填充到temp
			temp[t] = arr[j];
			t += 1;
			j += 1;	
		}
		
		
		//(三)
		//将temp数组的元素拷贝到arr
		//注意，并不是每次都拷贝所有
		t = 0;
		int tempLeft = left; // 
		//第一次合并 tempLeft = 0 , right = 1 //  tempLeft = 2  right = 3 // tL=0 ri=3
		//最后一次 tempLeft = 0  right = 7
		while(tempLeft <= right) { 
			arr[tempLeft] = temp[t];
			t += 1;
			tempLeft += 1;
		}		
	}
}

七、基数排序

基数排序（桶排序）介绍：

  1. 基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或 bin sort，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
  2. 基数排序法是属于稳定性的排序，基数排序法的是效率高的稳定性排序法
  3. 基数排序（Radix Sort）是桶排序的扩展
  4. 基数排序是 1887 年赫尔曼·何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较

基数排序基本思想：

  1. 将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。
  2. 图例如下
    第一轮排序：
    在这里插入图片描述
    第二轮排序：
    在这里插入图片描述
    第三轮排序：
    在这里插入图片描述
    实例： 将数组 { 53，3，542，748，14，214} 进行升序排列。
public class RadixSort {

	public static void main(String[] args) {
		int arr[] = { 53, 3, 542, 748, 14, 214};
		
		// 80000000 * 11 * 4 / 1024 / 1024 / 1024 =3.3G 内存
//		int[] arr = new int[8000000];
//		for (int i = 0; i < 8000000; i++) {
//			arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
//		}
		System.out.println("排序前");
		Date data1 = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String date1Str = simpleDateFormat.format(data1);
		System.out.println("排序前的时间是=" + date1Str);
		
		radixSort(arr);
		
		Date data2 = new Date();
		String date2Str = simpleDateFormat.format(data2);
		System.out.println("排序前的时间是=" + date2Str);
		
		System.out.println("基数排序后 " + Arrays.toString(arr));
		
	}

	//基数排序方法
	public static void radixSort(int[] arr) {
		
		//1. 得到数组中最大的数的位数
		int max = arr[0]; //假设第一数就是最大数
		for(int i = 1; i < arr.length; i++) {
			if (arr[i] > max) {
				max = arr[i];
			}
		}
		//得到最大数是几位数
		int maxLength = (max + "").length();
		
		
		//定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
		//说明
		//1. 二维数组包含10个一维数组
		//2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为arr.length
		//3. 明确，基数排序是使用空间换时间的经典算法
		int[][] bucket = new int[10][arr.length];
		
		//为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
		//可以这里理解
		//比如：bucketElementCounts[0] , 记录的就是  bucket[0] 桶的放入数据个数
		int[] bucketElementCounts = new int[10];
		
		
		for(int i = 0 , n = 1; i < maxLength; i++, n *= 10) {
			//(针对每个元素的对应位进行排序处理)， 第一次是个位，第二次是十位，第三次是百位..
			for(int j = 0; j < arr.length; j++) {
				//取出每个元素的对应位的值
				int digitOfElement = arr[j] / n % 10;
				//放入到对应的桶中
				bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
				bucketElementCounts[digitOfElement]++;
			}
			//按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
			int index = 0;
			//遍历每一桶，并将桶中是数据，放入到原数组
			for(int k = 0; k < bucketElementCounts.length; k++) {
				//如果桶中，有数据，我们才放入到原数组
				if(bucketElementCounts[k] != 0) {
					//循环该桶即第k个桶(即第k个一维数组), 放入
					for(int l = 0; l < bucketElementCounts[k]; l++) {
						//取出元素放入到arr
						arr[index++] = bucket[k][l];
					}
				}
				//第i+1轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
				bucketElementCounts[k] = 0;
				
			}
			//System.out.println("第"+(i+1)+"轮，对个位的排序处理 arr =" + Arrays.toString(arr));
			
		}
		
		/*以下为分析过程：
		
		//第1轮(针对每个元素的个位进行排序处理)
		for(int j = 0; j < arr.length; j++) {
			//取出每个元素的个位的值
			int digitOfElement = arr[j] / 1 % 10;
			//放入到对应的桶中
			bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
			bucketElementCounts[digitOfElement]++;
		}
		//按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
		int index = 0;
		//遍历每一桶，并将桶中是数据，放入到原数组
		for(int k = 0; k < bucketElementCounts.length; k++) {
			//如果桶中，有数据，我们才放入到原数组
			if(bucketElementCounts[k] != 0) {
				//循环该桶即第k个桶(即第k个一维数组), 放入
				for(int l = 0; l < bucketElementCounts[k]; l++) {
					//取出元素放入到arr
					arr[index++] = bucket[k][l];
				}
			}
			//第l轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
			bucketElementCounts[k] = 0;
			
		}
		System.out.println("第1轮，对个位的排序处理 arr =" + Arrays.toString(arr));
		
		
		//==========================================
		
		//第2轮(针对每个元素的十位进行排序处理)
		for (int j = 0; j < arr.length; j++) {
			// 取出每个元素的十位的值
			int digitOfElement = arr[j] / 10  % 10; //748 / 10 => 74 % 10 => 4
			// 放入到对应的桶中
			bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
			bucketElementCounts[digitOfElement]++;
		}
		// 按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
		index = 0;
		// 遍历每一桶，并将桶中是数据，放入到原数组
		for (int k = 0; k < bucketElementCounts.length; k++) {
			// 如果桶中，有数据，我们才放入到原数组
			if (bucketElementCounts[k] != 0) {
				// 循环该桶即第k个桶(即第k个一维数组), 放入
				for (int l = 0; l < bucketElementCounts[k]; l++) {
					// 取出元素放入到arr
					arr[index++] = bucket[k][l];
				}
			}
			//第2轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
			bucketElementCounts[k] = 0;
		}
		System.out.println("第2轮，对个位的排序处理 arr =" + Arrays.toString(arr));
		
		
		//第3轮(针对每个元素的百位进行排序处理)
		for (int j = 0; j < arr.length; j++) {
			// 取出每个元素的百位的值
			int digitOfElement = arr[j] / 100 % 10; // 748 / 100 => 7 % 10 = 7
			// 放入到对应的桶中
			bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
			bucketElementCounts[digitOfElement]++;
		}
		// 按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
		index = 0;
		// 遍历每一桶，并将桶中是数据，放入到原数组
		for (int k = 0; k < bucketElementCounts.length; k++) {
			// 如果桶中，有数据，我们才放入到原数组
			if (bucketElementCounts[k] != 0) {
				// 循环该桶即第k个桶(即第k个一维数组), 放入
				for (int l = 0; l < bucketElementCounts[k]; l++) {
					// 取出元素放入到arr
					arr[index++] = bucket[k][l];
				}
			}
			//第3轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
			bucketElementCounts[k] = 0;
		}
		System.out.println("第3轮，对个位的排序处理 arr =" + Arrays.toString(arr)); */
		
	}
}

各种排序算法时间复杂度比较：
在这里插入图片描述

玳宸
关注
专栏目录
冒泡排序 ，选择排序，插入排序，归并排序，快速排序，希尔排序，堆排序，计数排序，桶排序，基数排序的 C++实现
天天向上
04-01 512
文章目录冒泡排序 O(n*n)选择排序 O(n*n)归并排序 O(nlogN)快速排序排序 冒泡排序 O(n*n) 算法思路 两两比较，将两者较少的升上去，第一次比较下标范围为0到(N-1)，最后一轮比较空间为0到1 算法实现 可以看到，在此次运行中，把一万个数据排序，需要花674ms。 //冒泡排序 #include<iostream> #include<time.h> #include <iomanip> #include<stdlib.h> us
排序算法（冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、基数排序）
wardo_l的博客
03-18 6078
排序也叫排序算法，排序是将一组数据，依指定的顺序进行排列的过程。 排序的分类： 1）内部排序：指将需要处理的所有数据都加载到内部存储器中进行排序。 2）外部排序：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。 3）常见的排序算法分类： 内部排序： （1）插入排序：直接插入排序、希尔排序 （2）选择排序：简单选择排序、堆排序 （3）交换排序：冒泡排序、快速排序 （4）归并排序、基数排序 我们先回顾知识点：时间复杂度 时间频度：一个算法花费的时间与算法中语句的执行次数成正比例
八大排序（冒泡，选择，插入，希尔，快排，堆，归并，基数）总结一波
Prodigal
10-17 386
钱钱钱·
冒泡、插入、选择、归并、快速、希尔、堆、基数排序总结
DeaSun
06-08 437
冒泡排序 插入排序 选择排序 归并排序 快速排序 希尔排序 堆排序 基数排序
数据结构与算法-排序(冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，基数排序，堆排序)
weixin_42455070的博客
08-13 500
排序 定义 对一序列对象根据某个关键字进行排序。 术语 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面； 不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面； 内排序：所有排序操作都在内存中完成； 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行； 时间复杂度： 一个算法执行所耗费的时间。 空间复杂度：运行完一个程序所需内存的大小。 时间复杂度总结 n: 数据规模 k: “桶”的个数 In-place: 占用常数内存，不占用额外
十种排序算法：冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序
当我把这件事情做出来的时候，我想要的东西就已经拿到了
06-21 1855
排序算法(Sorting algorithm) 定义 对一序列对象根据某个关键字进行排序。 术语 稳定性：稳定排序算法会让原本有相等键值的纪录维持相对次序 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面； 不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面； 内排序：所有排序操作都在内存中完成； 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行； 时间复杂度： 一个算法执行所耗费的时间。 空间复杂度：运行完一个程序所需内存的大小。
Java实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
快速排序是一种高效的排序算法，由C.A.R. Hoare在1960年提出。基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，然后分别对这两部分记录继续进行排序，以达到...
用C实现了排序算法中的插入排序、选择排序、冒泡排序、希尔排序、归并排序、快速排序、桶排序、基数排序
最新发布
09-21
在这份文档中，我用C语言实现了排序算法的多种方法，包括插入排序、选择排序、冒泡排序、希尔排序、归并排序、快速排序、桶排序和基数排序。这些算法可以帮助我们对数据进行有效的排序和整理，以便更好地处理和分析...
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
在本文中，我们将深入探讨C++实现的八种常见的排序算法，它们分别是插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序。这些排序算法在计算机科学中有着广泛的应用，是理解和掌握...
C# 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序
10-15
- 快速排序由C.A.R. Hoare提出，采用分治策略。选取一个“基准”元素，将数组分为小于基准和大于基准两部分，然后递归地对这两部分进行快速排序。 - C# 中，快速排序的关键在于“分区操作”，通过一次遍历将数组...
冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、基数排序图解分析和代码演示
qq_45976767的博客
04-03 686
排序算法 1、内部排序：指将需要处理的的所有数据都需要加载到内部存储中进行排序 2、外部排序：数据量过大，无法将全部加载到内存中，需要借助外部存储进行排序 冒泡排序 介绍 通过从前往后遍历序列，依次比较相邻元素的值，将值较大的逐渐移动到最后 一共进行数组大小-1循环 每一趟排序的次数都在减少 优化，在某一次排序中没有发生一次交换，就可以提前结束循环 图解 代码实现 /** * 冒泡排序 */ public class BobbleSort { public static voi
冒泡排序、插入排序、归并排序和基数排序 时间复杂度
weixin_30770783的博客
07-30 372
选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。 冒泡法： 这是最原始，也是众所周知的最慢的算法了。他的名字的由来因为它的工作看来象是冒泡： 复杂度为O(n*n)。当数据为正序，将不会有交换。复杂度为O(0)。 直接插入排序：O(n*n) 选择排序：O(n*n) 快速排序：平均时间复杂度log2(n)*n，所有内部排...
【算法之八大排序（带图解、复杂度分析）】 优化版冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、基数排序、堆排序。
qmqm33的博客
02-19 610
文章目录前言排序算法介绍排序算法分类内部排序外部排序冒泡排序冒泡排序进行的排序过程一般冒泡排序优化冒泡排序算法选择排序选择排序图解选择排序代码实现插入排序插入排序图解代码实现希尔排序希尔排序图解希尔排序的两种方法希尔排序交换法代码实现希尔排序移动法代码实现（优化版）快速排序快速排序图解快速排序代码实现归并排序归并排序图解归并排序代码实现基数排序基数排序的基本介绍基数排序的基本思想基数排序代码实现堆...
八大基础排序总结（冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序、希尔排序、基数排序）
m0_46323151的博客
08-30 585
数据结构入门、排序算法 如果不接触一段时间的算法，真的很容易就忘记了，经历过校招的人都知道，算法和数据结构都是不可避免的，在面试和笔试的时候都会有遇到。 刚刚接触学习的同学，我们可以先以排序和各种数据结构入门。 冒泡排序 冒泡排序是一种简单的排序算法，它重复的走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来，走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经交换慢慢“浮“到数列顶端，像冒泡一样。 冒泡排序的思想就是两两交换
冒泡，归并，快速排序
Bruce_try的博客
01-06 202
冒泡排序：较小的数值逐渐浮向顶部，较大的数值逐渐沉向底部。具体操作：根据下标比较其值，即，位置１数值和位置２数值比较，数值２＞数值１则互换位置，否则继续比较位置２和位置３数值，依次后推。。。 代码如下： /*初始数组元素*/ int [] arr= {1,2,3,4,5,6,7}; /*冒泡排序*/ for(int j=0;jlength;j++){ for(int i=0;ile
十大排序详解：冒泡、选择、插入、希尔、归并、快速、堆、计数、桶、基数排序（python版）
qq_45812313的博客
12-05 894
十大排序详解：冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序（python版）
十大排序算法（冒泡，选择，插入，希尔，堆，快速，归并，计数，基数，桶）
wjasonk的博客
01-27 860
目录 冒泡: 选择： 插入： 希尔： 堆： 快速排序： 归并排序： 计数排序： 基数排序： 桶排序： 排序算法： 十种比较经典的排序算法：冒泡，选择，插入，希尔，堆，快速，归并，计数，基数，桶。每种算法在一定环境下各有各的优越性，需要根据数据的分布状况进行合理选择。 排序算法的稳定性： 当待排序的数据中有相同的数据，排序算法是否会更改它们的前后关系，不会更改的叫稳定排序，可能会更改的叫不稳定排序。 冒泡: 特点：对数据的有序性敏感 是否稳定：稳定 平均时间复杂度： O(n^2)
常用排序算法(一)插入排序、希尔排序、冒泡排序
一只大笨猫的博客
08-01 1268
1. 插入排序 算法 最简单的排序算法之一是插入排序（insertion sort）。插入排序由N-1趟（pass）排序组成。对于P=1趟到P=N-1趟，插入排序保证从位置0到位置P上的元素为已排序状态。插入排序利用了这样的事实：位置0到位置P-1上的元素是已排过序的。下图显示一个简单的数组在每一趟插入排序后的情况。 C语言给出算法参考程序如下，显然，插入排序算法复杂度为O(N2)O...
冒泡，快速，归并，快速排序算法
乌龙茶不是可燃的嘛的博客
07-16 426
排序算法 排序算法，字面意思上来说，就是用来排序的算法，我主要从简单到复杂介绍几个常见的排序。 首先引入两个问题，给我们两个已经排好序的数组和链表我们要怎么把他们合并成一个数组或者链表 int[] arr1 = new int[]{3,1,9,7}; int[] arr2 = new int[]{6,10,16,50}; 时间复杂度和空间复杂度 时间复杂度 假设我们有个数组，我们要查找数组中是否存在某个数 如何来衡量写的算法效率更高呢，可以用时间吗？是不可以的。所以我们引入时间复杂度的概念。 每访问一个元
详解常见排序算法：冒泡、选择、快速到归并
内排序算法的特点在于它们的稳定性，其中冒泡排序、插入排序、基数排序和归并排序被认为是稳定的排序方法，而选择排序、快速排序、希尔排序和堆排序则是不稳定的。 冒泡排序是一种直观且易于理解的算法，通过反复...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

玳宸

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值