尚硅谷数据结构与算法(Java)--18--基数排序

：基数排序 

基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）

或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到

排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的

基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。

图片链接https://www.runoob.com/wp-content/uploads/2019/03/radixSort.gif

package com.atguigu.sort;

import java.text.SimpleDateFormat;
import java.time.Clock;
import java.util.Arrays;
import java.util.Date;

//**** 基数排序 ****
public class RadixSort {

	public static void main(String[] args) {
		//
		int[] arr = { 53, 3, 542, 748, 14, 214 };
		System.out.println("基数排序前："+Arrays.toString(arr));
		radixSort(arr);
		System.out.println("基数排序后："+Arrays.toString(arr));
		timeSort();

	}

	/**
	 * **** 基数排序 ****
	 * 
	 * @param arr 数组
	 */
	public static void radixSort(int[] arr) {
		// 1.得到数组中最大的数的位数
		int max = arr[0];
		for (int i = 0; i < arr.length - 1; i++) {
			if (arr[i] > max)
				max = arr[i];
		}
		// 得到最大数的位数
		int maxLength = (max + "").length();

		int[][] bucket = new int[10][arr.length];
		/*
		 * 为了记录每个桶中实际存放了多少数据，定义一个一维数组记录每个桶每一轮放入数据个数
		 * 如：bucketElementCount[0],记录的是bucket[0] 桶的放入的数据个数 *
		 */
		int[] bucketElementCount = 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;
				// 放入对应的桶
				bucket[digitOfElement][bucketElementCount[digitOfElement]] = arr[j];
				bucketElementCount[digitOfElement]++;
			}
			// 按照桶的顺序（一维数组的下标依次取出数据，放入原数组）
			int index = 0;
			// 遍历每一个桶，并将桶中的数据，放入原数组
			for (int k = 0; k < bucketElementCount.length; k++) {
				if (bucketElementCount[k] != 0) {// 如果桶中，有数据，我们放入到原数组
					for (int l = 0; l < bucketElementCount[k]; l++) {// 循环该桶即第k个桶（第k个一维数组）放入
						arr[index++] = bucket[k][l];// 取出元素放入到arr
					}
				}
				// 第i+1轮处理后，需要把 bucketElementCount[k] 置为 0；!!!!!
				bucketElementCount[k] = 0;
			}
//			System.out.println("第" + (i + 1) + "轮：" + Arrays.toString(arr));
		}

	}

	// 耗时测试
	public static void timeSort() {
		// 测试排序的速度（O(n^2)）,给80000个数据
		// 创建一个80000个随机数的数组
		/*占用内存 80000000*11*4/1024/1024/1024 = 3.3GB */
		int[] arr = new int[8000000];
		int temp[] = new int[arr.length];// 归并排序需要一个额外空间
		for (int i = 0; i < 8000000; i++) {
			arr[i] = (int) (Math.random() * 8000000);// 生成一个【0,8000000】数
		}

		Date data1 = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String date1Str = simpleDateFormat.format(data1);
		System.out.println("800万个随机数据-排序前的时间是： " + date1Str);
		// 获取排序前时间
		long s = Clock.systemDefaultZone().millis();
		radixSort(arr);
		// 打印 八万个随机数据【希尔排序-交换法】 总耗时间
		System.out.println("800万个随机数据【归并排序】耗时: " + (Clock.systemDefaultZone().millis() - s) + " ms");
		Date data2 = new Date();

		String date2Str = simpleDateFormat.format(data2);
		System.out.println("800万个随机数据-排序后的时间是： " + date2Str);

	}
	
	
	}