当前位置: 首页 > 面试题库 >

Java版基数排序[稳定]

高山
2023-03-14
本文向大家介绍Java版基数排序[稳定]相关面试题,主要包含被问及Java版基数排序[稳定]时的应答技巧和注意事项,需要的朋友参考一下

原理:分配加收集

复杂度: O(d(n+r)) r为基数d为位数 空间复杂度O(n+r)

// 基数排序
	public void radixSort(int[] a, int begin, int end, int digit) {
		// 基数
		final int radix = 10;
		// 桶中的数据统计
		int[] count = new int[radix];
		int[] bucket = new int[end-begin+1];
		
		// 按照从低位到高位的顺序执行排序过程
		for (int i = 1; i <= digit; i++) {
			// 清空桶中的数据统计
			for (int j = 0; j < radix; j++) {
				count[j] = 0;
			}
			
			// 统计各个桶将要装入的数据个数
			for (int j = begin; j <= end; j++) {
				int index = getDigit(a[j], i);
				count[index]++;
			}
			
			// count[i]表示第i个桶的右边界索引
			for (int j = 1; j < radix; j++) {
				count[j] = count[j] + count[j - 1]; 
			}
			
			// 将数据依次装入桶中
            // 这里要从右向左扫描,保证排序稳定性 
			for (int j = end; j >= begin; j--) {
				int index = getDigit(a[j], i);
				bucket[count[index] - 1] = a[j];
				count[index]--;
			}
			
			// 取出,此时已是对应当前位数有序的表
			for (int j = 0; j < bucket.length; j++) {
				a[j] = bucket[j];
			}
		}
	}
	
	// 获取x的第d位的数字,其中最低位d=1
	private int getDigit(int x, int d) {
		String div = "1";
		while (d >= 2) {
			div += "0";
			d--;
		}
		return x/Integer.parseInt(div) % 10;
	}
}
 类似资料:
  • 本文向大家介绍Java版归并排序[稳定]相关面试题,主要包含被问及Java版归并排序[稳定]时的应答技巧和注意事项,需要的朋友参考一下 原理:采用分治法 复杂度:O(nlogn) - O(nlgn) - O(nlgn) - O(n)[平均 - 最好 - 最坏 - 空间复杂度]

  • 本文向大家介绍Java版堆排序[不稳定]相关面试题,主要包含被问及Java版堆排序[不稳定]时的应答技巧和注意事项,需要的朋友参考一下 堆一般指二叉堆。 复杂度:O(nlogn) - O(nlgn) - O(nlgn) - O(1)[平均 - 最好 - 最坏 - 空间复杂度] 大顶堆实现从小到大的升序排列,小顶堆一般用于构造优先队列

  • 本文向大家介绍Java版冒泡排序[稳定]相关面试题,主要包含被问及Java版冒泡排序[稳定]时的应答技巧和注意事项,需要的朋友参考一下 复杂度:O(n^2) - O(n) - O(n^2) - O(1)[平均 - 最好 - 最坏 - 空间复杂度]

  • 本文向大家介绍Java版插入排序[稳定]相关面试题,主要包含被问及Java版插入排序[稳定]时的应答技巧和注意事项,需要的朋友参考一下 适用于小数组,数组已排好序或接近于排好序速度将会非常快 复杂度:O(n^2) - O(n) - O(n^2) - O(1)[平均 - 最好 - 最坏 - 空间复杂度]

  • 本文向大家介绍Java版快速排序[不稳定]相关面试题,主要包含被问及Java版快速排序[不稳定]时的应答技巧和注意事项,需要的朋友参考一下 原理:分治+递归 复杂度:O(nlgn) - O(nlgn) - O(n^2) - O(1)[平均 - 最好 - 最坏 - 空间复杂度] 栈空间0(lgn) - O(n)

  • 本文向大家介绍Java版选择排序[不稳定]相关面试题,主要包含被问及Java版选择排序[不稳定]时的应答技巧和注意事项,需要的朋友参考一下 原理:每次从无序序列选取最小的 复杂度:O(n^2) - O(n^2) - O(n^2) - O(1)[平均 - 最好 - 最坏 - 空间复杂度]