排序算法之基数排序(7)

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

7.基数排序

7.1实现思路

在这里插入图片描述

7.2具体实现

1.第一轮排序

public class RadixSort {

	public static void main(String[] args) {
		int[] arr = { 5, 234, 34, 48, 135, 3 };
		radixSort(arr);
		System.out.println("第一轮，对个位数的排序处理：" + Arrays.toString(arr));
	}

	public static void radixSort(int[] arr) {
		// 第一轮(针对每个元素的个位进行排序处理)

		// 定义一个二维数组，表示10个桶，每个桶就是一个一维数组
		// 说明：
		// 为了防止放入数据时溢出，每一个一维数组的大小定为arr.length
		int[][] bucket = new int[10][arr.length];

		// 为了记录每个桶中，实际存放了多少个数据，定义一个一维数组来记录每次放入的数据个数
		// 可以这样理解
		// 比如说：bucketElemetnCounts[0],记录的就是bucket[0]桶的放入数据的个数
		int[] bucketElemetnCounts = new int[10];

		// 第一轮(针对每个元素的个位进行排序处理)
		for (int j = 0; j < arr.length; j++) {
			// 取出每个元素的个位的值
			int digitOfElement = arr[j] % 10;
			// 放入到对应的桶中
			// 说明：比如说我的第一个数为2，2%10=2
			// bucketElemetnCounts[digitOfElement]=bucketElemetnCounts[2]，记录的是第2个桶里面元素的个数
			bucket[digitOfElement][bucketElemetnCounts[digitOfElement]] = arr[j];
			bucketElemetnCounts[digitOfElement]++;
		}
		// 按照这个桶的顺序(一维数组的下标依次取出数据，放入原来的数组)
		int index = 0;
		// 遍历每一个桶，并将桶中的数据，放入到原数组
		for (int k = 0; k < bucketElemetnCounts.length; k++) {
			// 如果桶中有数据，我们才取
			if (bucketElemetnCounts[k] != 0) {
				// 遍历该桶
				for (int l = 0; l < bucketElemetnCounts[k]; l++) {
					// 取出元素放入到原数组
					arr[index] = bucket[k][l];
					index++;
				}
			}
		}
	}
}

第一轮，对个位数的排序处理：[3, 234, 34, 5, 135, 48]

2.第二轮排序

public class RadixSort {

	public static void main(String[] args) {
		int[] arr = { 5, 234, 34, 48, 135, 3 };
		radixSort(arr);

	}

	public static void radixSort(int[] arr) {
		// 第一轮(针对每个元素的个位进行排序处理)

		// 定义一个二维数组，表示10个桶，每个桶就是一个一维数组
		// 说明：
		// 为了防止放入数据时溢出，每一个一维数组的大小定为arr.length
		int[][] bucket = new int[10][arr.length];

		// 为了记录每个桶中，实际存放了多少个数据，定义一个一维数组来记录美再次放入的数据个数
		// 可以这样理解
		// 比如说：bucketElemetnCounts[0],记录的就是bucket[0]桶的放入数据的个数
		int[] bucketElemetnCounts = new int[10];

		// 第一轮(针对每个元素的个位进行排序处理)
		for (int j = 0; j < arr.length; j++) {
			// 取出每个元素的个位的值
			int digitOfElement = arr[j] % 10;
			// 放入到对应的桶中
			// 说明：比如说我的第一个数为5234，5%10=0
			// bucketElemetnCounts[digitOfElement]=bucketElemetnCounts[0]
			bucket[digitOfElement][bucketElemetnCounts[digitOfElement]] = arr[j];
			bucketElemetnCounts[digitOfElement]++;
		}
		// 按照这个桶的顺序(一维数组的下标依次取出数据，放入原来的数组)
		int index = 0;
		// 遍历每一个桶，并将桶中的数据，放入到原数组
		for (int k = 0; k < bucketElemetnCounts.length; k++) {
			// 如果桶中有数据，我们才取
			if (bucketElemetnCounts[k] != 0) {
				// 遍历该桶
				for (int l = 0; l < bucketElemetnCounts[k]; l++) {
					// 取出元素放入到原数组
					arr[index] = bucket[k][l];
					index++;
				}
			}
			// 特别注意，我们在第二次向桶里面放数据时，桶里面应该是空的
			bucketElemetnCounts[k] = 0;
		}
		System.out.println("第一轮，对个位数的排序处理：" + Arrays.toString(arr));
		// 第二轮(针对每个元素的十位进行排序处理)

		// 定义一个二维数组，表示10个桶，每个桶就是一个一维数组
		// 说明：
		// 为了防止放入数据时溢出，每一个一维数组的大小定为arr.length
		int[][] bucket1 = new int[10][arr.length];

		// 为了记录每个桶中，实际存放了多少个数据，定义一个一维数组来记录美再次放入的数据个数
		// 可以这样理解
		// 比如说：bucketElemetnCounts[0],记录的就是bucket[0]桶的放入数据的个数
		int[] bucketElemetnCounts1 = new int[10];

		// 第二轮(针对每个元素的十位进行排序处理)
		for (int j = 0; j < arr.length; j++) {
			// 取出每个元素的个位的值
			int digitOfElement = arr[j] / 10 % 10;
			// 放入到对应的桶中
			// 说明：比如说我的第一个数为234，234/10=23 23%10=3
			// bucketElemetnCounts[digitOfElement]=bucketElemetnCounts[0]
			bucket1[digitOfElement][bucketElemetnCounts1[digitOfElement]] = arr[j];
			bucketElemetnCounts1[digitOfElement]++;
		}
		// 按照这个桶的顺序(一维数组的下标依次取出数据，放入原来的数组)
		index = 0;
		// 遍历每一个桶，并将桶中的数据，放入到原数组
		for (int k = 0; k < bucketElemetnCounts1.length; k++) {
			// 如果桶中有数据，我们才取
			if (bucketElemetnCounts1[k] != 0) {
				// 遍历该桶
				for (int l = 0; l < bucketElemetnCounts1[k]; l++) {
					// 取出元素放入到原数组
					arr[index] = bucket1[k][l];
					index++;
				}
			}
			// 特别注意，我们在第三次向桶里面放数据时，桶里面应该是空的
						bucketElemetnCounts[k] = 0;
		}
		System.out.println("第二轮，对十位数的排序处理：" + Arrays.toString(arr));		
	}
}


第一轮，对个位数的排序处理：[3, 234, 34, 5, 135, 48]
第二轮，对十位数的排序处理：[3, 5, 234, 34, 135, 48]

3.第三轮

public class RadixSort {

	public static void main(String[] args) {
		int[] arr = { 5, 234, 34, 48, 135, 3 };
		radixSort(arr);

	}

	public static void radixSort(int[] arr) {
		// 第一轮(针对每个元素的个位进行排序处理)

		// 定义一个二维数组，表示10个桶，每个桶就是一个一维数组
		// 说明：
		// 为了防止放入数据时溢出，每一个一维数组的大小定为arr.length
		int[][] bucket = new int[10][arr.length];

		// 为了记录每个桶中，实际存放了多少个数据，定义一个一维数组来记录美再次放入的数据个数
		// 可以这样理解
		// 比如说：bucketElemetnCounts[0],记录的就是bucket[0]桶的放入数据的个数
		int[] bucketElemetnCounts = new int[10];

		// 第一轮(针对每个元素的个位进行排序处理)
		for (int j = 0; j < arr.length; j++) {
			// 取出每个元素的个位的值
			int digitOfElement = arr[j] % 10;
			// 放入到对应的桶中
			// 说明：比如说我的第一个数为5234，5%10=0
			// bucketElemetnCounts[digitOfElement]=bucketElemetnCounts[0]
			bucket[digitOfElement][bucketElemetnCounts[digitOfElement]] = arr[j];
			bucketElemetnCounts[digitOfElement]++;
		}
		// 按照这个桶的顺序(一维数组的下标依次取出数据，放入原来的数组)
		int index = 0;
		// 遍历每一个桶，并将桶中的数据，放入到原数组
		for (int k = 0; k < bucketElemetnCounts.length; k++) {
			// 如果桶中有数据，我们才取
			if (bucketElemetnCounts[k] != 0) {
				// 遍历该桶
				for (int l = 0; l < bucketElemetnCounts[k]; l++) {
					// 取出元素放入到原数组
					arr[index] = bucket[k][l];
					index++;
				}
			}
			// 特别注意，我们在第二次向桶里面放数据时，桶里面应该是空的
			bucketElemetnCounts[k] = 0;
		}
		System.out.println("第一轮，对个位数的排序处理：" + Arrays.toString(arr));
		// 第二轮(针对每个元素的十位进行排序处理)

		// 定义一个二维数组，表示10个桶，每个桶就是一个一维数组
		// 说明：
		// 为了防止放入数据时溢出，每一个一维数组的大小定为arr.length
		int[][] bucket1 = new int[10][arr.length];

		// 为了记录每个桶中，实际存放了多少个数据，定义一个一维数组来记录美再次放入的数据个数
		// 可以这样理解
		// 比如说：bucketElemetnCounts[0],记录的就是bucket[0]桶的放入数据的个数
		int[] bucketElemetnCounts1 = new int[10];

		// 第二轮(针对每个元素的十位进行排序处理)
		for (int j = 0; j < arr.length; j++) {
			// 取出每个元素的个位的值
			int digitOfElement = arr[j] / 10 % 10;
			// 放入到对应的桶中
			// 说明：比如说我的第一个数为234，234/10=23 23%10=3
			// bucketElemetnCounts[digitOfElement]=bucketElemetnCounts[0]
			bucket1[digitOfElement][bucketElemetnCounts1[digitOfElement]] = arr[j];
			bucketElemetnCounts1[digitOfElement]++;
		}
		// 按照这个桶的顺序(一维数组的下标依次取出数据，放入原来的数组)
		index = 0;
		// 遍历每一个桶，并将桶中的数据，放入到原数组
		for (int k = 0; k < bucketElemetnCounts1.length; k++) {
			// 如果桶中有数据，我们才取
			if (bucketElemetnCounts1[k] != 0) {
				// 遍历该桶
				for (int l = 0; l < bucketElemetnCounts1[k]; l++) {
					// 取出元素放入到原数组
					arr[index] = bucket1[k][l];
					index++;
				}
			}
			// 特别注意，我们在第三次向桶里面放数据时，桶里面应该是空的
						bucketElemetnCounts[k] = 0;
		}
		System.out.println("第二轮，对十位数的排序处理：" + Arrays.toString(arr));
		
			  	// 第三轮(针对每个元素的百位进行排序处理)

				// 定义一个二维数组，表示10个桶，每个桶就是一个一维数组
				// 说明：
				// 为了防止放入数据时溢出，每一个一维数组的大小定为arr.length
				int[][] bucket2 = new int[10][arr.length];

				// 为了记录每个桶中，实际存放了多少个数据，定义一个一维数组来记录美再次放入的数据个数
				// 可以这样理解
				// 比如说：bucketElemetnCounts[0],记录的就是bucket[0]桶的放入数据的个数
				int[] bucketElemetnCounts2 = new int[10];

				// 第三轮(针对每个元素的百位进行排序处理)
				for (int j = 0; j < arr.length; j++) {
					// 取出每个元素的个位的值
					int digitOfElement = arr[j] / 100 % 10;
					// 放入到对应的桶中
					// 说明：比如说我的第一个数为234，234/10=23 23%10=3
					// bucketElemetnCounts[digitOfElement]=bucketElemetnCounts[0]
					bucket2[digitOfElement][bucketElemetnCounts2[digitOfElement]] = arr[j];
					bucketElemetnCounts2[digitOfElement]++;
				}
				// 按照这个桶的顺序(一维数组的下标依次取出数据，放入原来的数组)
				index = 0;
				// 遍历每一个桶，并将桶中的数据，放入到原数组
				for (int k = 0; k < bucketElemetnCounts2.length; k++) {
					// 如果桶中有数据，我们才取
					if (bucketElemetnCounts2[k] != 0) {
						// 遍历该桶
						for (int l = 0; l < bucketElemetnCounts2[k]; l++) {
							// 取出元素放入到原数组
							arr[index] = bucket2[k][l];
							index++;
						}
					}
				}
				System.out.println("第三轮，对百位数的排序处理：" + Arrays.toString(arr));
	}
}

第一轮，对个位数的排序处理：[3, 234, 34, 5, 135, 48]
第二轮，对十位数的排序处理：[3, 5, 234, 34, 135, 48]
第三轮，对百位数的排序处理：[3, 5, 34, 48, 135, 234]

4.代码优化

public class RadixSort1 {

	public static void main(String[] args) {
		int[] arr = { 5, 234, 34, 48, 135, 3 };
		radixSort(arr);
		System.out.println(Arrays.toString(arr));

	}

	public static void radixSort(int[] arr) {
		// 第一轮(针对每个元素的个位进行排序处理)

		// 定义一个二维数组，表示10个桶，每个桶就是一个一维数组
		// 说明：
		// 为了防止放入数据时溢出，每一个一维数组的大小定为arr.length
		int[][] bucket = new int[10][arr.length];

		// 为了记录每个桶中，实际存放了多少个数据，定义一个一维数组来记录美再次放入的数据个数
		// 可以这样理解
		// 比如说：bucketElemetnCounts[0],记录的就是bucket[0]桶的放入数据的个数
		int[] bucketElemetnCounts = new int[10];

		int max = 0;
		// 遍历求出最大值
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] > max) {
				max = arr[i];
			}
		}
		int maxLength = (max + "").length();
		for (int j = 0, n = 1; j < maxLength; j++, n *= 10) {
			// 针对每个元素的位进行排序处理
			for (int l = 0; l < arr.length; l++) {
				// 取出每个元素的个位的值
				int digitOfElement = arr[l] / n % 10;
				// 放入到对应的桶中
				// 说明：比如说我的第一个数为5234，5%10=0
				// bucketElemetnCounts[digitOfElement]=bucketElemetnCounts[0]
				bucket[digitOfElement][bucketElemetnCounts[digitOfElement]] = arr[l];
				bucketElemetnCounts[digitOfElement]++;
			}
			// 按照这个桶的顺序(一维数组的下标依次取出数据，放入原来的数组)
			int index = 0;
			// 遍历每一个桶，并将桶中的数据，放入到原数组
			for (int k = 0; k < bucketElemetnCounts.length; k++) {
				// 如果桶中有数据，我们才取
				if (bucketElemetnCounts[k] != 0) {
					// 遍历该桶
					for (int l = 0; l < bucketElemetnCounts[k]; l++) {
						// 取出元素放入到原数组
						arr[index] = bucket[k][l];
						index++;
					}
				}
				// 特别注意，我们在第二次向桶里面放数据时，桶里面应该是空的
				bucketElemetnCounts[k] = 0;
			}
		}

	}
}

[3, 5, 34, 48, 135, 234]

7.3测试基数排序算法的速度

public class RadixSort1 {

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

	}

	public static void radixSort(int[] arr) {
		// 第一轮(针对每个元素的个位进行排序处理)

		// 定义一个二维数组，表示10个桶，每个桶就是一个一维数组
		// 说明：
		// 为了防止放入数据时溢出，每一个一维数组的大小定为arr.length
		int[][] bucket = new int[10][arr.length];

		// 为了记录每个桶中，实际存放了多少个数据，定义一个一维数组来记录美再次放入的数据个数
		// 可以这样理解
		// 比如说：bucketElemetnCounts[0],记录的就是bucket[0]桶的放入数据的个数
		int[] bucketElemetnCounts = new int[10];

		int max = 0;
		// 遍历求出最大值
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] > max) {
				max = arr[i];
			}
		}
		int maxLength = (max + "").length();
		for (int j = 0, n = 1; j < maxLength; j++, n *= 10) {
			// 针对每个元素的位进行排序处理
			for (int l = 0; l < arr.length; l++) {
				// 取出每个元素的个位的值
				int digitOfElement = arr[l] / n % 10;
				// 放入到对应的桶中
				// 说明：比如说我的第一个数为5234，5%10=0
				// bucketElemetnCounts[digitOfElement]=bucketElemetnCounts[0]
				bucket[digitOfElement][bucketElemetnCounts[digitOfElement]] = arr[l];
				bucketElemetnCounts[digitOfElement]++;
			}
			// 按照这个桶的顺序(一维数组的下标依次取出数据，放入原来的数组)
			int index = 0;
			// 遍历每一个桶，并将桶中的数据，放入到原数组
			for (int k = 0; k < bucketElemetnCounts.length; k++) {
				// 如果桶中有数据，我们才取
				if (bucketElemetnCounts[k] != 0) {
					// 遍历该桶
					for (int l = 0; l < bucketElemetnCounts[k]; l++) {
						// 取出元素放入到原数组
						arr[index] = bucket[k][l];
						index++;
					}
				}
				// 特别注意，我们在第二次向桶里面放数据时，桶里面应该是空的
				bucketElemetnCounts[k] = 0;
			}
		}

	}
}


排序前的时间是：2021-01-09 21:03:18
排序后的时间是：2021-01-09 21:03:18
Coder-liu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
经典排序算法之基数排序
10-18
经典排序算法之基数排序
java 实现归并排序
照母山挖洋芋
09-23 258
https://mp.csdn.net/console/editor/html/108763772这篇文章实现了插入排序 插入排序相对比较简单也好理解，但是插入排序的时间复杂是很高的 O(n^2) 所以需要对插入排序进行优化，这里我们使用归并排序来进行优化 归并排序 通过二分的思想将数组元素拆分到只剩一个为止，在对我们的元素进行合并处理，合并的时候需要比较数组中的元素大小 时间复杂度：O(n log n) 稳定性：稳定 图解 /**以数组 int [] data = {6,5,3,7,...
bootstrap table 分组_Bootstrap table的基本使用总结
weixin_26849971的博客
12-23 1234
$('#exampleTable').bootstrapTable({method:'get', //服务器数据的请求方式 get or posturl: prefix + "/list", //服务器数据的加载地址//showRefresh : true,//showToggle : true,//showColumns : true,iconSize: 'outline',toolbar:'#...
BootstrapTable（附源码） Bootstrap结合BootstrapTable的使用，分为两种模试显示列表。...
weixin_30598225的博客
08-17 325
引用的css： <link href="@Url.Content("~/Css/bootstrap.min.css")" rel="stylesheet" type="text/css" /> <link href="@Url.Content("~/Css/bootstrap-table.css")" rel="stylesheet" type="text/...
bootstraptable 分页循环_前端框架：Bootstrap table 分页，排序，搜索 记录
weixin_39983383的博客
12-20 248
做CRM或其他后台系统 ，必需至少掌握一个前端框架。之前学习使用EASYUI写了一个小系统 ，感觉还蛮好用的，就是外观不太好看。所以现在学习主流的响应式框架 Bootstrap。感觉外观还真是变好看的~哈1.引用JS 使用的是 bootstrap-3.3.5-dist2.引用table插件 bootstrap-table.js(谷歌搜索下就有~)3.引用paginator插件 bootstra...
bootstrap table 数据行合并
放松不放纵的博客
12-20 3197
转自：http://blog.163.com/cyguchunze@126/blog/static/63839716201662945339644/ //根据数据源 data     动态分组算出    合并行数  $('#TableName').bootstrapTable('mergeCells', { index: 0, field: '类别名称', colspa
经典算法:基数排序的小例子
01-01
基数排序(Radix sort)是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于...
PHP排序算法之基数排序(Radix Sort)实例详解
10-18
主要介绍了PHP排序算法之基数排序(Radix Sort),结合实例形式详细分析了php基数排序算法的原理、实现方法与相关使用技巧,需要的朋友可以参考下
详解Java常用排序算法-基数排序
08-26
详解Java常用排序算法-基数排序
基数排序_基数排序算法_
09-30
利用关键字序列，打印输出基数排序的每一趟结果。
使用bootstrap写的关于table表格的显示和折叠效果
11-14
使用bootstrap，配合JQ写的关于table表格的显示和折叠效果。点击实现table表格的折叠后，显示+号，再次点击，伸展表格中的内容，并显示-号
bootstrap获取表格中选中行的值_bootstrapTable 数据表格 点击行选中行内容
weixin_39755003的博客
12-19 831
用post请求的时候必须加上contentType:"application/x-www-form-urlencoded; charset=UTF-8",var $table;//初始化bootstrap-table的内容function InitMainTable () {//记录页面bootstrap-table全局变量$table，方便应用var queryUrl = '/TestUser/...
一、二维数组以及多维数组
bdubvxhbxb的博客
10-12 711
一、二维数组以及多维数组 1、二维数组定义： ​ 在一维数组中定义每一个元素也是一个数组元素，这样的数组称为“二维数组” ​ 多维数组就是在一维数组上再次定义二维数组或三维数组等。 ​ 一维数组定义 int [] array = { 1, 2 , 3} //定义三个长度的二维数组，其数组的每一个元素是一个一维数组 int [][] arrays = {{} ，{} ，{}} ； 或者 int [][] arrays = new int [3][2]; // 左边的【
【Leetcode】877. Stone Game
数学、算法爱好者的博客
01-31 287
题目地址： https://leetcode.com/problems/stone-game/ 给定一个正整数数组，设一个两人游戏，甲乙轮流走。甲可以先从数组中的两端取一个数，加到自己的分数上，同时取过的就从数组中删掉；然后乙接着从数组中的两端取，这样一直直到整个数组被取完。初始两人分数都是000，问最后谁能获胜。 法1：DFS+记忆化。用一个整数二维数组f[i][j]f[i][j]f[i][j]...
二维数组的本质
Think88666的博客
06-02 1万+
在C/C++中无论是几维的数组，那必然是连续的内存空间。 那对于二维数组，是怎么解释的呢？ 我们可以这样理解： 实则上二维数组也是一个一维的数组，比如int a[5][4] ，这个数组的长度是5，每一个元素又都是一个数组int[4]。 从以下代码可以证明二维数组是连续空间，而且正如上面描述的那样： int main() { int a[5][5]; for (int i...
二维数组（理论）
热门推荐
以太以北
10-18 1万+
二维数组
【数据结构--二维数组】
qq_61719813的博客
05-24 2706
文章目录二维数组二维数组定义二维数组的创建二维数组的应用矩阵加法矩阵乘法 二维数组 二维数组定义 二维数组本质上是以数组作为数组元素的数组，即数组的数组。 二维数组就是一个有行和列的矩阵，每一行代表一个数组，即数组的数组； 每一行数组内元素所在的位置可以用行和列号来表示 二维数组的创建 动态二维数组 动态二维数组图示 elements是动态二维数组变量，其是指向包含两个整型元素数组的指针（即指向二维数组首地址），elements[0]、elements[1]、elements[2]存储的值为一个包含两
C语言二维数组和二重指针详解
qq_28576837的博客
01-05 1741
C语言二维数组和二重指针详解
bootstrap表格动态合并行和列
qq_54378364的博客
04-21 2472
/ 获取bootstrap的加载完毕的数据，dataList为表格id，mergeCells为boostrap自带的方法。//这其实就是bootstrap的mergeCells属性 自带的合并单元格。bootstrap表格数据加载完成是触发mergeCells()方法。// 初始化合并索引。
链式基数排序算法原理
最新发布
12-22
链式基数排序算法是基数排序的一种变体，它使用链表作为桶来存储相同基数的元素。其原理如下： 1. 首先，确定排序的基数，例如十进制数中的个位、十位、百位等。 2. 创建一个链表桶数组，数组的大小等于基数的取值...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值