基数排序详解以及java实现

基数排序详解以及java实现这篇讲的很清楚,附上本人自己写的代码,将空间位n*10减为了n;


package suanfa;




import java.util.Arrays;
import java.util.Scanner;import java.util.concurrent.CountDownLatch;

public class Main {
	
	public static void main (String[] args) {
		int[] arr = {34,52,33,45,35};
	//	int[] arr1 = {1,2,3,4,5};
		radixSort(arr,getDigit(arr));
		System.out.println(Arrays.toString(arr));
	}
	
	public static void radixSort(int [] arr ,int digit) {
		int[] count = new int[10];//记录每个桶的下标;
		int k;
		int[] bucket = new int [arr.length];//辅助排序数组
		for(int i=1;i<=digit;i++) {
			for(int j=0;j<count.length;j++) {//初始化计算桶下标数组
				count[j] = 0;
			}
			for(int j=0;j<arr.length;j++) {
				count[getDigitNum(arr[j], i)]++;//记录第i位数值位bitNum的数量;
				
			}
			System.out.println(Arrays.toString(count));
			for(k=1;k<count.length;k++) {//记录第k个桶的下标
				count[k] = count[k]+count[k-1];
				
			}
			System.out.println(Arrays.toString(count));
			for(int j = arr.length-1;j>=0;j--) {
				bucket[count[getDigitNum(arr[j], i)]-1] = arr[j];
				count[getDigitNum(arr[j], i)]--;
			}
			for(int j=0;j<arr.length;j++) {
				arr[j] = bucket[j];
			}
		}
		
	}
	public static int getDigitNum(int bitNum,int i) {//求第i位的数值bitNum;
		//System.out.println(((int)Math.pow(10, i-1))%10);
		return bitNum/((int)Math.pow(10, i-1))%10;
	}
	public static int getDigit(int[] arr) {
		int maxNum = 0;
		int digit = 0;
		for(int i =0 ;i< arr.length;i++) {//寻找最大数;
			if(arr[i] > maxNum) {
				maxNum = arr[i];
			}
		}
		while(maxNum>0) {//求最大数的位数
			digit++;
			maxNum /= 10;
		}
		System.out.println(digit);
		return digit;
	}
}

桶排序思想解决一道编程题:有n个数,求相邻两位数的最大差值,时间复杂度位O(n)。显然这题如果先排序再比较的话时间最少要nO(logn),所以使用桶排序的思想,即找到最大值与最小值,将这部分差值空间分位n+1份,然后建立n+1个桶,将这些数分到这些桶里,显然可知必然存在一个空桶,所以相邻两数的差值必然不在同一一个桶中(因为在同一桶中的差值必然小于桶的区间值),如

34,38,33,31,43

最大与最小差值位12,分成六分,

(1)【31-33) :31;

(2)【33-35): 33,34;

(3)【35-37): 空;

(4)【37-39):38;

(5)【39-41):空;

(6)【41-43】:43

显然可知,同一桶的值最大差值小于2,相邻桶的最小差值>=2;所以问题转化位求相邻非空桶的最大值与最小值的差之间的比较。即 33-31,38-34;43-38,之间值得比较可得最大差值位5.。

	public static int maxGap(int[] nums) {
		if (nums == null || nums.length < 2) {
			return 0;
		}
		int len = nums.length;
		int min = Integer.MAX_VALUE;
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < len; i++) {
			min = Math.min(min, nums[i]);
			max = Math.max(max, nums[i]);
		}
		if (min == max) {
			return 0;
		}
		boolean[] hasNum = new boolean[len + 1];
		int[] maxs = new int[len + 1];
		int[] mins = new int[len + 1];
		int bid = 0;
		for (int i = 0; i < len; i++) {
			bid = bucket(nums[i], len, min, max);
			mins[bid] = hasNum[bid] ? Math.min(mins[bid], nums[i]) : nums[i];
			maxs[bid] = hasNum[bid] ? Math.max(maxs[bid], nums[i]) : nums[i];
			hasNum[bid] = true;
		}
		int res = 0;
		int lastMax = maxs[0];
		int i = 1;
		for (; i <= len; i++) {
			if (hasNum[i]) {
				res = Math.max(res, mins[i] - lastMax);
				lastMax = maxs[i];
			}
		}
		return res;
	}

	public static int bucket(long num, long len, long min, long max) {
		return (int) ((num - min) * len / (max - min));
	}







猜你喜欢

转载自blog.csdn.net/u014683368/article/details/80079395
今日推荐