基数排序

基数排序(桶排序)介绍

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

基数排序基本思想

将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。 这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

代码实现

package com.liang.sort;

import java.util.Arrays;

public class RadixSort {
	public static void main(String[] args) {
		int[] arr= {53, 3, 542, 748, 14, 214};
		radixSort02(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	/*
	 * 推导
	 */
	public static void radixSort01(int[] arr) {
		//定义10个桶，每个桶的长度为arr的长度，防止溢出。用空间换取时间
		int[][] bucket=new int[10][arr.length];
		//10个桶中，每个桶存放的数据数量
		int[] bucketOfCounts=new int[10];
		
		
		//第1轮
		//把元素放入桶中
		for(int j=0;j<arr.length;j++) {
			int bucketOfIndex=(arr[j]%10);//arr[j]元素对应哪个桶，取个位
			//吧元素放入对应的桶中
			bucket[bucketOfIndex][bucketOfCounts[bucketOfIndex]]=arr[j];
			bucketOfCounts[bucketOfIndex]++;//桶中数量++
			
		}
		//从桶中按顺序取出元素，放到arr[]
		int index=0;
		for(int b=0;b<10;b++) {
			if(bucketOfCounts[b]!=0) {//桐中有数据
				for(int l=0;l<bucketOfCounts[b];l++) {//遍历取出桐中的数据
					arr[index++]=bucket[b][l];
				}
			}
			//将此时已经取出所有数据的桶中的数量清0,为下次做准备
			bucketOfCounts[b]=0;
		}
		System.out.println("第1轮" + Arrays.toString(arr));
		
		// 第2轮
		// 把元素放入桶中
		for (int j = 0; j < arr.length; j++) {
			int bucketOfIndex = (arr[j]/10 % 10);// arr[j]元素对应哪个桶,取十位
			// 吧元素放入对应的桶中
			bucket[bucketOfIndex][bucketOfCounts[bucketOfIndex]] = arr[j];
			bucketOfCounts[bucketOfIndex]++;// 桶中数量++

		}
		// 从桶中按顺序取出元素，放到arr[]
		index = 0;
		for (int b = 0; b < 10; b++) {
			if (bucketOfCounts[b] != 0) {// 桐中有数据
				for (int l = 0; l < bucketOfCounts[b]; l++) {// 遍历取出桐中的数据
					arr[index++] = bucket[b][l];
				}
			}
			// 将此时已经取出所有数据的桶中的数量清0,为下次做准备
			bucketOfCounts[b] = 0;
		}
		System.out.println("第2轮" + Arrays.toString(arr));
		
		// 第3轮
		// 把元素放入桶中
		for (int j = 0; j < arr.length; j++) {
			int bucketOfIndex = (arr[j]/100 % 10);// arr[j]元素对应哪个桶，取百位
			// 吧元素放入对应的桶中
			bucket[bucketOfIndex][bucketOfCounts[bucketOfIndex]] = arr[j];
			bucketOfCounts[bucketOfIndex]++;// 桶中数量++

		}
		// 从桶中按顺序取出元素，放到arr[]
		index = 0;
		for (int b = 0; b < 10; b++) {
			if (bucketOfCounts[b] != 0) {// 桐中有数据
				for (int l = 0; l < bucketOfCounts[b]; l++) {// 遍历取出桐中的数据
					arr[index++] = bucket[b][l];
				}
			}
			// 将此时已经取出所有数据的桶中的数量清0,为下次做准备
			bucketOfCounts[b] = 0;
		}
		System.out.println("第3轮" + Arrays.toString(arr));
	}
	
	/*
	 * 整合，优化
	 */
	public static void radixSort02(int[] arr) {
		//找到数组中最大的数
		int max=arr[0];
		for(int i=1;i<arr.length;i++) {
			if(arr[i]>max) {
				max=arr[i];
			}
		}
		//得出要循环几轮
		int maxLength=(max+"").length();
		
		for(int i=0,n=1;i<maxLength;i++,n*=10) {
			//定义10个桶，每个桶的长度为arr的长度，防止溢出。用空间换取时间
			int[][] bucket=new int[10][arr.length];
			//10个桶中，每个桶存放的数据数量
			int[] bucketOfCounts=new int[10];
			//把元素放入桶中
			for(int j=0;j<arr.length;j++) {
				int bucketOfIndex=(arr[j]/n%10);//arr[j]元素对应哪个桶，取个位
				//吧元素放入对应的桶中
				bucket[bucketOfIndex][bucketOfCounts[bucketOfIndex]]=arr[j];
				bucketOfCounts[bucketOfIndex]++;//桶中数量++
				
			}
			//从桶中按顺序取出元素，放到arr[]
			int index=0;
			for(int b=0;b<10;b++) {
				if(bucketOfCounts[b]!=0) {//桐中有数据
					for(int l=0;l<bucketOfCounts[b];l++) {//遍历取出桐中的数据
						arr[index++]=bucket[b][l];
					}
				}
				//将此时已经取出所有数据的桶中的数量清0,为下次做准备
				bucketOfCounts[b]=0;
			}
		}
	}
}