Java学习——数据结构——基数排序

学习尚硅谷韩顺平老师的Java数据结构笔记，详情请移步网站

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

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

3. 图文说明
   将数组 {53, 3, 542, 748, 14, 214} 使用基数排序, 进行升序排序
   
   
   

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 arrSize = 80000;//定义数组大小
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//时间格式化
        int[] arr = createNumbers(arrSize);

        Date start = new Date();//开始时间
        System.out.println("开始: " + simpleDateFormat.format(start));

        radixSort(arr);

        Date end = new Date();//结束时间
        System.out.println("结束: " + simpleDateFormat.format(end));
    }

    private static void radixSort(int[] arr) {
        //定义一个二维数组表示10个桶
        int[][] bucket = new int[10][arr.length];
        //定义一个统计每个桶每次放入多少个数据的数组
        int[] bucketElementCounts = new int[10];

        //得到数组中最大的数
        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) {
            //对每位数进行排序
            for (int j = 0; j < arr.length; j++) {
                //取出每个元素的个位的值
                int digitOfElement = (arr[j] /n) % 10;
                //放入对应的桶中
                bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
                //对应的计数数组值增加
                bucketElementCounts[digitOfElement]++;
            }

            //按照桶的顺序放回原来的数组
            int index = 0;
            //遍历每个桶，并将每个桶的数据放回到原数组
            for (int k = 0; k < bucketElementCounts.length; k++) {
                //如果桶中有数据，则将数据放回
                if (bucketElementCounts[k] != 0){
                    //循环取出数据放回
                    for (int j = 0; j < bucketElementCounts[k]; j++) {
                        arr[index++] = bucket[k][j];
                    }
                }
                //一轮过后需要将统计数组置0
                bucketElementCounts[k] = 0;
            }
            //System.out.println(Arrays.toString(arr));
        }
    }

    //生成随机数数组
    public static int[] createNumbers(int arrSize) {
        int arr[] = new int[arrSize];
        for (int i = 0; i < arrSize; i++) {
            arr[i] = (int) (Math.random()*8000000);//生成一个0到8000000的数
        }
        return arr;
    }
}

4. 说明
   4.1 基数排序是对传统桶排序的扩展，速度很快.
   4.2 基数排序是经典的空间换时间的方式，占用内存很大, 当对海量数据排序时，容易造成 OutOfMemoryError 。
   4.3 基数排序时稳定的。[注:假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且 r[i]在 r[j]之前，而在排序后的序列中，r[i]仍在 r[j]之前， 则称这种排序算法是稳定的；否则称为不稳定的]
   4.4有负数的数组，我们不用基数排序来进行排序, 如果要支持负数，参考: https://code.i-harness.com/zh-CN/q/e98fa9