基数排序

不包含负数基数排序算法

  public static void radixsort(int[] arrs){
        int maxnum=arrs[0];
        for(int i=0;i<arrs.length;i++){
            if(maxnum<arrs[i]){
                maxnum=arrs[i];
            }
        }
        int maslength=(maxnum+"").length();
        int n=1;
        for(int i=0;i<maslength;i++,n*=10){
            int[][] buckets=new int[10][arrs.length-1];
            int[] bucketcount=new int[10];
            for(int j=0;j<arrs.length;j++){
                int digitOfElement=arrs[j]/n%10;
                buckets[digitOfElement][bucketcount[digitOfElement]]=arrs[j];
                bucketcount[digitOfElement]++;
            }
            int j=0;
            for(int k=0;k<10;k++){
                for(int m=0;m<bucketcount[k];m++){
                    arrs[j]=buckets[k][m];
                    j++;
                }
            }
        }
    }

##包含负数的基数排序算法

将负数和正数分别分两组，然后正数和负数分别按照基数排序，排好之后合并

    int posiIndex=0;
        int negeIndex=0;
        for(int num:arrs){
            if(num>=0){
                posiIndex++;
            }else{
                negeIndex++;
            }
        }
        int[] positiveArr=new int[posiIndex];
        int[] negative=new int[negeIndex];
        posiIndex=0;
        negeIndex=0;
        for(int num:arrs){
            if(num>=0){
                positiveArr[posiIndex]=num;
                posiIndex++;
            }else{
                negative[negeIndex]=num;
                negeIndex++;
            }
        }
        int left=0;
        int mid=negeIndex;
        int right=arrs.length-1;
        if(mid<right){
            int posimaxnum=positiveArr[0];
            for(int i=0;i<positiveArr.length;i++){
                if(posimaxnum<positiveArr[i]){
                    posimaxnum=positiveArr[i];
                }
            }
            int maslength=(posimaxnum+"").length();
            int n=1;
            for(int i=0;i<maslength;i++,n*=10){
                int[][] buckets=new int[10][positiveArr.length];
                int[] bucketcount=new int[10];
                for(int j=0;j<positiveArr.length;j++){
                    int digitOfElement=positiveArr[j]/n%10;
                    buckets[digitOfElement][bucketcount[digitOfElement]]=positiveArr[j];
                    bucketcount[digitOfElement]++;
                }
                int j=0;
                for(int k=0;k<10;k++){
                    for(int m=0;m<bucketcount[k];m++){
                        positiveArr[j]=buckets[k][m];
                        j++;
                    }
                }
            }
            for(int p=0;p<positiveArr.length;p++){
                arrs[mid+p]=positiveArr[p];
            }
        }
        if(left<mid){
            int negmin=negative[0];
            for(int i=0;i<negative.length;i++){
                if(negmin>negative[i]){
                    negmin=negative[i];
                }
            }
            int negminlen=(negmin+"").length()-1;
            int n=1;
            for(int i=0;i<negminlen;i++,n*=10){
                int[][] buckets=new int[10][negative.length];
                int[] bucketcount=new int[10];
                for(int j=0;j<negative.length;j++){
                    int digitOfElement=Math.abs(negative[j])/n%10;
                    buckets[digitOfElement][bucketcount[digitOfElement]]=negative[j];
                    bucketcount[digitOfElement]++;
                }
                int j=0;
                for(int k=0;k<10;k++){
                    for(int m=0;m<bucketcount[k];m++){
                        negative[j]=buckets[k][m];
                        j++;
                    }
                }
            }
            int negposi=0;
            for(int p=negative.length-1;p>=0;p--){
                arrs[left+negposi]=negative[p];
                negposi++;
            }
        }