基数排序

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

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

基数排序排序图解：
数组的初始数组 arr={53，3，542，748，14，214}
第一轮：
看个位
2 ：542
3 ：53 3
4 ：14 214
8 ：748
此时排序位：542 53 3 14 214 748
第二轮：
看十位，没有十位的补0
0 ：3
1 ：14 214
4 ：542 748
5 ：53
此时排序位：3 14 214 542 748 53
第三轮：
看百位，没有百位补0
0 ：3 14 53
2 ：214
5 ：542
7 ：748
此时排序位：3 14 53 214 542 748

package com.sort;

import java.text.SimpleDateFormat;
import java.util.Date;

public class RadixSort {
	public static void main(String[] args) {
//		int[] arr = {53,3,542,748,14,214};
		int[] arr = new int[80000];
		for(int i=0;i<80000;i++) {
			arr[i]=(int)(Math.random()*800000000);//給定0到800000的八万个数据
		}
		Date data1 = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
		String data1Str = simpleDateFormat.format(data1);
		System.out.println("排序前的时间："+data1Str);

		RaidxSort(arr);

		Date data2 = new Date();
		String data2Str = simpleDateFormat.format(data2);
		System.out.println("排序后的时间："+data2Str);
	}
	public static void RaidxSort(int [] arr) {
		
		//定义一个二维数组，表示10个桶分别表示0~9的数
		//1、二维数组包含10个一维数组
		//2、为了防止在放入数的时候，数据溢出，则每个一维数组（桶），大小定义为arr.length。因为最多的只有arr里面的个数
		//3、明确，基数排序是使用空间时间的经典算法
		int[][] bucket = new int[10][arr.length];
		//为记录每个桶中，实际存放了多少个数据，我们定义一个一维数组来记录各个桶的放入数据个数
		//比如：bucketElementCounts = new int[10];
		int[] bucketElementCounts = new int[10];
		
		//封装
		//1.首先找到最大数，判断有几位，就说明有几轮排序
		//2.把下面的取位数代码改一下
		//取最大值
		int max = 0;
		int left,right;
		left = 0;
		right = arr.length-1;
		while (left<right) {
			if(arr[left]<arr[right]) left++;
			if(arr[left]>arr[right]) right--;
		}
		max = arr[right];
		//把最大值判断几位
		int maxLength = (max + "").length();
		for(int i = 0,n = 1;i<maxLength;i++,n *= 10) {
			for(int j = 0;j<arr.length;j++) {
				//取出每个元素的对应位的值
				int digitOfElemnt = arr[j]/n%10;
				//放入到对应的桶中
				bucket[digitOfElemnt][bucketElementCounts[digitOfElemnt]] = arr[j];
				bucketElementCounts[digitOfElemnt]++;//桶里数据加一个
			}
			
			//按照这个桶的顺序（一维数组的下标依次取出数据，放入原来数组）
			int index = 0;
			//遍历每一桶，并将桶中数据，放入到原数组
			for(int k = 0;k<bucketElementCounts.length;k++) {
				//遍历每个桶，桶里有数据，将数据放回原数组
				if(bucketElementCounts[k] != 0) {
					//在第k桶里有数据
					for(int l = 0;l<bucketElementCounts[k];l++) {
						//取出所有的元素放到arr
						arr[index++] = bucket[k][l];//覆盖一个数，index下一位
						
					}
				}
				//放回完数据后必须将桶内的数据置零，以便于下一轮的运算
				bucketElementCounts[k] = 0;
			}
//			System.out.println("第"+(i+1)+"轮排序arr = "+Arrays.toString(arr));
//			第1轮排序arr = [542, 53, 3, 14, 214, 748]
//			第2轮排序arr = [3, 14, 214, 542, 748, 53]
//			第3轮排序arr = [3, 14, 53, 214, 542, 748]
		}
		/*
		//第一轮（针对每个元素的个位进行排序处理）
		for(int j = 0;j<arr.length;j++) {
			//取出每个元素的个位的值
			int digitOfElemnt = arr[j]%10;
			//放入到对应的桶中
			bucket[digitOfElemnt][bucketElementCounts[digitOfElemnt]] = arr[j];
			bucketElementCounts[digitOfElemnt]++;//桶里数据加一个
		}
		
		//按照这个桶的顺序（一维数组的下标依次取出数据，放入原来数组）
		int index = 0;
		//遍历每一桶，并将桶中数据，放入到原数组
		for(int k = 0;k<bucketElementCounts.length;k++) {
			//遍历每个桶，桶里有数据，将数据放回原数组
			if(bucketElementCounts[k] != 0) {
				//在第k桶里有数据
				for(int l = 0;l<bucketElementCounts[k];l++) {
					//取出所有的元素放到arr
					arr[index++] = bucket[k][l];//覆盖一个数，index下一位
					
				}
			}
			//放回完数据后必须将桶内的数据置零，以便于下一轮的运算
			bucketElementCounts[k] = 0;
		}
		System.out.println("第一轮排序arr = "+Arrays.toString(arr));
		
		
		
		// 第二轮（针对每个元素的个位进行排序处理）
		for (int j = 0; j < arr.length; j++) {
			// 取出每个元素的个位的值
			int digitOfElemnt = arr[j] / 10 % 10;//取十位
			// 放入到对应的桶中
			bucket[digitOfElemnt][bucketElementCounts[digitOfElemnt]] = arr[j];
			bucketElementCounts[digitOfElemnt]++;// 桶里数据加一个
		}

		// 按照这个桶的顺序（一维数组的下标依次取出数据，放入原来数组）
		index = 0;
		// 遍历每一桶，并将桶中数据，放入到原数组
		for (int k = 0; k < bucketElementCounts.length; k++) {
			// 遍历每个桶，桶里有数据，将数据放回原数组
			if (bucketElementCounts[k] != 0) {
				// 在第k桶里有数据
				for (int l = 0; l < bucketElementCounts[k]; l++) {
					// 取出所有的元素放到arr
					arr[index++] = bucket[k][l];// 覆盖一个数，index下一位

				}
			}
			// 放回完数据后必须将桶内的数据置零，以便于下一轮的运算
			bucketElementCounts[k] = 0;
		}
		System.out.println("第二轮排序arr = " + Arrays.toString(arr));
		
		// 第三轮（针对每个元素的个位进行排序处理）
		for (int j = 0; j < arr.length; j++) {
			// 取出每个元素的个位的值
			int digitOfElemnt = arr[j] / 100%10;//取百位
			// 放入到对应的桶中
			bucket[digitOfElemnt][bucketElementCounts[digitOfElemnt]] = arr[j];
			bucketElementCounts[digitOfElemnt]++;// 桶里数据加一个
		}

		// 按照这个桶的顺序（一维数组的下标依次取出数据，放入原来数组）
		index = 0;
		// 遍历每一桶，并将桶中数据，放入到原数组
		for (int k = 0; k < bucketElementCounts.length; k++) {
			// 遍历每个桶，桶里有数据，将数据放回原数组
			if (bucketElementCounts[k] != 0) {
				// 在第k桶里有数据
				for (int l = 0; l < bucketElementCounts[k]; l++) {
					// 取出所有的元素放到arr
					arr[index++] = bucket[k][l];// 覆盖一个数，index下一位

				}
			}
			// 放回完数据后必须将桶内的数据置零，以便于下一轮的运算
			bucketElementCounts[k] = 0;
		}
		System.out.println("第三轮排序arr = " + Arrays.toString(arr));
	*/	
	}
}
排序前的时间：2020-09-26 21:55:29 120
排序后的时间：2020-09-26 21:55:29 165