java的数据结构与算法（25）基数排序

基数排序

实际上就是对桶排序的优化

思想

代码块

package cn.itjy.sort;

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

/**
 * 基数排序
 * 
 * @author 86183
 */
public class RadixSort {
	public static void main(String[] args) {
//		int[] arr = { 53, 3, 542, 748, 14, 214 };
		Random r = new Random();
		int[] arr = new int[800000];
		for (int j = 0; j < arr.length; j++) {
			arr[j] = r.nextInt(80000000);
		}
		SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		String startTime = sd.format(new Date());
		System.out.println("排序前的时间=" + startTime);
		radixSort(arr);
		SimpleDateFormat sd2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		String endTime = sd2.format(new Date());
		System.out.println("排序后的时间=" + endTime);
	}

	// 基数排序法
	public static void radixSort(int[] arr) {
		// 根据前面的推导过程，我们可以得到最终的基数的排序的代码
		// 1.需要得到最大的位数
		int max = arr[0]; // 假设第一个是最大的
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] > max) {
				max = arr[i];
			}
		}
		int maxLength = (max + "").length();
		int[][] bucket = new int[10][arr.length];
		int[] bucketElementCounts = new int[10];
		for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
			for (int j = 0; j < arr.length; j++) {
				// 取出每个元素的各位
				int digitOfElement = arr[j] / n % 10;
				// System.out.println(digitOfElement);
				// 放入到对应的桶中
				bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
				bucketElementCounts[digitOfElement]++;

			}
			// 按照这个桶的顺序（一维数组的下标依次取出，放入原来的数组）
			int index = 0;
			// 遍历每一个桶，并将桶中的数据，放入到原数组中

			for (int k = 0; k < bucketElementCounts.length; k++) {
				// 如果桶中有数据，我们才放入到原数组
				if (bucketElementCounts[k] != 0) {
					// 循环该桶即第k个桶（即第k个一维数组），放入
					for (int l = 0; l < bucketElementCounts[k]; l++) {
						arr[index++] = bucket[k][l];
					}
				}
				// 第一轮处理后，需要将每个bucketElementCounts[k] = 0 !!!
				bucketElementCounts[k] = 0;
			}
		}

		// 第一轮排序（针对每个元素的个位进行排序处理）
		// 定义一个二维数组表示10个桶，每个桶就是一个一维数组
		// 1.二维数组包含10个一维数组
		// 2.为了防止在放入数的时候数据溢出，每个一维数组（桶），大小定为arr.length
		// 3.基数排序是使用空间换时间的经典算法
		/*
		 * int[][] bucket = new int[10][arr.length];
		 * 
		 * // 为了记录每个桶中 ，实际存放了多少个数据，我们定义一个一维数组来记录各个桶的每次放入的数据 // 可以这样理解 //
		 * 比如：bucketElementCounts，记录的就是 bucket[0] 桶的放入数据的个数 int[] bucketElementCounts =
		 * new int[10]; for (int j = 0; j < arr.length; j++) { // 取出每个元素的各位 int
		 * digitOfElement = arr[j] % 10; // System.out.println(digitOfElement); //
		 * 放入到对应的桶中 bucket[digitOfElement][bucketElementCounts[digitOfElement]] =
		 * arr[j]; bucketElementCounts[digitOfElement]++;
		 * 
		 * } // 按照这个桶的顺序（一维数组的下标依次取出，放入原来的数组） int index = 0; // 遍历每一个桶，并将桶中的数据，放入到原数组中
		 * 
		 * for (int k = 0; k < bucketElementCounts.length; k++) { // 如果桶中有数据，我们才放入到原数组
		 * if (bucketElementCounts[k] != 0) { // 循环该桶即第k个桶（即第k个一维数组），放入 for (int l = 0;
		 * l < bucketElementCounts[k]; l++) { arr[index++] = bucket[k][l]; } } //
		 * 第一轮处理后，需要将每个bucketElementCounts[k] = 0 !!! bucketElementCounts[k] = 0; }
		 * System.out.println("one:" + Arrays.toString(arr)); for (int j = 0; j <
		 * arr.length; j++) { // 取出每十位个元素的各位 int digitOfElement = arr[j] / 10 % 10; //
		 * System.out.println(digitOfElement); // 放入到对应的桶中
		 * bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
		 * bucketElementCounts[digitOfElement]++;
		 * 
		 * } // 按照这个桶的顺序（一维数组的下标依次取出，放入原来的数组） index = 0; // 遍历每一个桶，并将桶中的数据，放入到原数组中 for
		 * (int k = 0; k < bucketElementCounts.length; k++) { // 如果桶中有数据，我们才放入到原数组 if
		 * (bucketElementCounts[k] != 0) { // 循环该桶即第k个桶（即第k个一维数组），放入 for (int l = 0; l <
		 * bucketElementCounts[k]; l++) { arr[index++] = bucket[k][l]; }
		 * 
		 * } bucketElementCounts[k] = 0; } System.out.println("two:" +
		 * Arrays.toString(arr));
		 * 
		 * for (int j = 0; j < arr.length; j++) { // 取出每百个元素的各位 int digitOfElement =
		 * arr[j] / 100 % 10; // System.out.println(digitOfElement); // 放入到对应的桶中
		 * bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
		 * bucketElementCounts[digitOfElement]++;
		 * 
		 * } // 按照这个桶的顺序（一维数组的下标依次取出，放入原来的数组） index = 0; // 遍历每一个桶，并将桶中的数据，放入到原数组中 for
		 * (int k = 0; k < bucketElementCounts.length; k++) { // 如果桶中有数据，我们才放入到原数组 if
		 * (bucketElementCounts[k] != 0) { // 循环该桶即第k个桶（即第k个一维数组），放入 for (int l = 0; l <
		 * bucketElementCounts[k]; l++) { arr[index++] = bucket[k][l]; }
		 * 
		 * } bucketElementCounts[k] = 0; } System.out.println("three:" +
		 * Arrays.toString(arr));
		 */

	}
}

总结：总体来说还是比较简单的。