基数排序-RadixSort

将整数按位切割成不同的数字，然后按每个位数分别比较。

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

 

新建一个二维数组 桶容器，每个桶的长度为arr[]的最大值

由10个桶，代表着，个（十，百）位数 

public static void sort(int arr[]) {
		int max=arr[0];
		for(int i=0;i<arr.length;i++) {
			if(arr[i]>max) {
				max=arr[i];
			}
		}
		int n=1;
		int maxLength=(max+"").length();
		int[][] bucket=new int[10][arr.length];
		int[] elementCount=new int[10];
		for(int i=0;i<maxLength;i++) {
			int element=arr[i]*n%10;
			bucket[element][elementCount[element]]=arr[i];
			elementCount[element]++;
		}
		//取
		int index=0;
		for(int k=0;k<elementCount.length;k++) {
			for(int l=0;l<elementCount[k];l++) {
				arr[index]=bucket[k][l];
				index++;
			}
			elementCount[k]=0;
		}
		n=n*10;
	}

 将arr[]中的最大值找出来

int max=arr[0];
		for(int i=0;i<arr.length;i++) {
			if(arr[i]>max) {
				max=arr[i];
			}
		}

 判断其最大的位数

	int maxLength=(max+"").length();

 建立桶bucket

建立记录每个桶中个数的数组

int[][] bucket=new int[10][arr.length];
		int[] elementCount=new int[10];

 遍历

建立element记录其个（十，百）位数是多少，次数代表着哪一个桶

arr[i]/n%10 当n=1时element是代表个位数 当n=10代表十位数 当n=100代表百位数

 将数组中每个树的个（十，百）位数对应数字装进对应桶中

并用elementCount[element]记录个数

for (int i = 0; i < arr.length; i++) {
			    int element=arr[i]/n%10;
			    bucket[element][elementCount[element]]=arr[i];
			    elementCount[element]++;
		}

取数据

外层循环是对所有桶检查，判断个数是否为零

如果不为零，则说明当前桶有数，

内层循环对单个桶中数据进行遍历，将桶中的数据放入数组中

一轮处理之后，将elementCount清零，如果不清零，那些空数据的桶也会进行遍历

int index=0;
		for(int k=0;k<elementCount.length;k++) {
			if(elementCount[k] !=0) {
				//循环遍历，将桶当中的数据放入
				for (int l = 0; l < elementCount[k]; l++) {
					arr[index++] = bucket[k][l];
				}
			}
			//第一轮处理后 bucketElementCounts[k] 置0  ，，，这个很重要
			elementCount[k] = 0;
		}

 切换位

n=n*10;
		System.out.println("第"+(h+1)+"轮的排序结构"+Arrays.toString(arr));

 进行下一轮循环

	for(int h=0;h<maxLength;h++) {
			for (int i = 0; i < arr.length; i++) {
			    int element=arr[i]/n%10;
			    bucket[element][elementCount[element]]=arr[i];
			    elementCount[element]++;
		}
		//取
		int index=0;
		for(int k=0;k<elementCount.length;k++) {
			if(elementCount[k] !=0) {
				//循环遍历，将桶当中的数据放入
				for (int l = 0; l < elementCount[k]; l++) {
					arr[index++] = bucket[k][l];
				}
			}
			//第一轮处理后 bucketElementCounts[k] 置0  ，，，这个很重要
			elementCount[k] = 0;
		}
		n=n*10;
		System.out.println("第"+(h+1)+"轮的排序结构"+Arrays.toString(arr));
	    }

源代码：

import java.util.Arrays;

public class RadixSort {

	public static void main(String[] args) {
		int arr[]= {56,5,68,666,2};
		 sort(arr);
	     System.out.println(Arrays.toString(arr));
	}
	public static void sort(int arr[]) {
		int max=arr[0];
		for(int i=0;i<arr.length;i++) {
			if(arr[i]>max) {
				max=arr[i];
			}
		}
		int n=1;
		int maxLength=(max+"").length();
		int[][] bucket=new int[10][arr.length];
		int[] elementCount=new int[10];
		
		for(int h=0;h<maxLength;h++) {
			for (int i = 0; i < arr.length; i++) {
			    int element=arr[i]/n%10;
			    bucket[element][elementCount[element]]=arr[i];
			    elementCount[element]++;
		}
		//取
		int index=0;
		for(int k=0;k<elementCount.length;k++) {
			if(elementCount[k] !=0) {
				//循环遍历，将桶当中的数据放入
				for (int l = 0; l < elementCount[k]; l++) {
					arr[index++] = bucket[k][l];
				}
			}
			//第一轮处理后 bucketElementCounts[k] 置0  ，，，这个很重要
			elementCount[k] = 0;
		}
		n=n*10;
		System.out.println("第"+(h+1)+"轮的排序结构"+Arrays.toString(arr));
	    }
}
}