标签：sort arr int 算法 基数排序 Date 排序

基数排序(桶排序)介绍

 

 

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

基数排序基本思想

 

 

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

 

 

1. 这样说明，比较难理解，下面我们看一个图文解释，理解基数排序的步骤

 

 

基数排序图文说明

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

 

 

 

 

基数排序代码实现

要求：将数组 {53, 3, 542, 748, 14, 214} 使用基数排序, 进行升序排序

package com.xuge.sort;

import java.util.Arrays;

/**
 * author: yjx
 * Date :2022/5/3022:05
 **/
public class RadixSort {
  public static void main(String[] args) {
    int[] arr = {53, 3, 542, 748, 14, 214};
    redisSort(arr);
  }

  public static void redisSort(int[] arr) {
    //1.得到数组中最大的位数
    int max = arr[0];

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

    int maxLength = (max + "").length();
    //2.遍历maxLength轮
    for (int i = 0 ,n=1; i < maxLength; i++,n*=10) {
      //针对每一个位排序
      //1.第一轮排序 针对每个元素各位
      //2.二维数组包含10个一维数组，每个一维数组大小定位arr.length;
      //3.是使用空间换时间的经典算法
      int[][] buceket = new int[10][arr.length];

      //为了记录每个桶实际存放的数据个数
      //buceketElementCounts[0]记录第0个桶放入数据个数
      int[] buceketElementCounts = new int[10];
      for (int j = 0; j < arr.length; j++) {
        //取出每个元素的个位数
        int digitOfElement = arr[j] /n%10;
        //放入到对应桶中
        buceket[digitOfElement][buceketElementCounts[digitOfElement]] = arr[j];
        //后移
        buceketElementCounts[digitOfElement]++;
      }
      //按造这个桶的顺序（一维数组下标，依次取出数据，放入原来数组)
      int index = 0;
      //遍历每一个桶，依次取数据
      for (int k = 0; k < buceketElementCounts.length; k++) {
        //如果桶中有数据，才放入数据
        if (buceketElementCounts[k] != 0) {
          //循环第k个桶,即第k个一维数组
          for (int l = 0; l < buceketElementCounts[k]; l++) {
            //取出元素放入arr[index]中
            arr[index++] = buceket[k][l];
          }

        }
        //第一轮处理后，需要将buceketElementCounts置0
        buceketElementCounts[k] = 0;

      }
      System.out.println("第"+(i+1)+"轮排序:" + Arrays.toString(arr));
    }



    /*
    //1.第一轮排序 针对每个元素各位
    //2.二维数组包含10个一维数组，每个一维数组大小定位arr.length;
    //3.是使用空间换时间的经典算法
    int [] [] buceket=new int [10][arr.length];

    //为了记录每个桶实际存放的数据个数
    //buceketElementCounts[0]记录第0个桶放入数据个数
    int []buceketElementCounts=new int [10];
    for(int j=0;j<arr.length;j++){
      //取出每个元素的个位数
      int digitOfElement=arr[j]%10;
      //放入到对应桶中
      buceket[digitOfElement][buceketElementCounts[digitOfElement]]=arr[j];
      //后移
      buceketElementCounts[digitOfElement]++;
    }
    //按造这个桶的顺序（一维数组下标，依次取出数据，放入原来数组)
    int index=0;
    //遍历每一个桶，依次取数据
    for(int k=0;k<buceketElementCounts.length;k++){
      //如果桶中有数据，才放入数据
      if(buceketElementCounts[k]!=0){
        //循环第k个桶,即第k个一维数组
        for(int l=0;l<buceketElementCounts[k];l++){
          //取出元素放入arr[index]中
          arr[index++]=buceket[k][l];
        }

      }
      //第一轮处理后，需要将buceketElementCounts置0
      buceketElementCounts[k]=0;

    }
    System.out.println("第一轮排序:"+ Arrays.toString(arr));



    for(int j=0;j<arr.length;j++){
      //取出每个元素的十位数
      int digitOfElement=arr[j]/10%10;
      //放入到对应桶中
      buceket[digitOfElement][buceketElementCounts[digitOfElement]]=arr[j];
      //后移
      buceketElementCounts[digitOfElement]++;
    }
    //按造这个桶的顺序（一维数组下标，依次取出数据，放入原来数组)
    index=0;
    //遍历每一个桶，依次取数据
    for(int k=0;k<buceketElementCounts.length;k++){
      //如果桶中有数据，才放入数据
      if(buceketElementCounts[k]!=0){
        //循环第k个桶,即第k个一维数组
        for(int l=0;l<buceketElementCounts[k];l++){
          //取出元素放入arr[index]中
          arr[index++]=buceket[k][l];
        }

      }
      //第二轮处理后，需要将buceketElementCounts置0
      buceketElementCounts[k]=0;
    }
    System.out.println("第二轮排序:"+ Arrays.toString(arr));



    for(int j=0;j<arr.length;j++){
      //取出每个元素的十位数
      int digitOfElement=arr[j]/100;
      //放入到对应桶中
      buceket[digitOfElement][buceketElementCounts[digitOfElement]]=arr[j];
      //后移
      buceketElementCounts[digitOfElement]++;
    }
    //按造这个桶的顺序（一维数组下标，依次取出数据，放入原来数组)
    index=0;
    //遍历每一个桶，依次取数据
    for(int k=0;k<buceketElementCounts.length;k++){
      //如果桶中有数据，才放入数据
      if(buceketElementCounts[k]!=0){
        //循环第k个桶,即第k个一维数组
        for(int l=0;l<buceketElementCounts[k];l++){
          //取出元素放入arr[index]中
          arr[index++]=buceket[k][l];
        }

      }
      //第二轮处理后，需要将buceketElementCounts置0
      buceketElementCounts[k]=0;
    }
    System.out.println("第三轮排序:"+ Arrays.toString(arr));
    */


  }
}

 

测试速度

 public static void main(String[] args) {
//    int[] arr = {53, 3, 542, 748, 14, 214};
//    redisSort(arr);
    int arr2[] = new int[800000];
    for (int i = 0; i < 800000; i++) {
      arr2[i] = (int) (Math.random() * 800000000);//生成随机数[0,80000000);
    }
    System.out.println("====输出数组=====");
    Date data = new Date();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String str = sdf.format(data);
    System.out.println("排序前的时间是:" + str);//23
    redisSort(arr2);
    Date data2 = new Date();
    String str2 = sdf.format(data2);
    System.out.println("排序后的时间是" + str2);//25
  }

　　

 

 

　

 

 

标签：sort,arr,int,算法,基数排序,Date,排序
来源： https://www.cnblogs.com/XugeA/p/16328675.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。