基于JAVA的排序算法之九--基数排序

九、基数排序

java代码实现：

 

01.   

04.import java.util.Arrays;    

05.public class RadixSort {      

06.     

07.         

13.    public int digit(long x, long d) {      

14.     

15.        long pow = 1;      

16.        while (--d > 0) {      

17.            pow *= 10;      

18.        }      

19.        return (int) (x / pow % 10);      

20.    }      

21.     

22.         

30.    public long[] radixSortAsc(long[] arr) {      

31.        //从低位往高位循环      

32.        for (int d = 1; d <= getMax(arr); d++) {      

33.            //临时数组，用来存放排序过程中的数据      

34.            long[] tmpArray = new long[arr.length];      

35.            //位记数器，从第0个元素到第9个元素依次用来记录当前比较位是0的有多少个..是9的有多少个数      

36.            int[] count = new int[10];      

37.            //开始统计0有多少个，并存储在第0位，再统计1有多少个，并存储在第1位..依次统计到9有多少个      

38.            for (int i = 0; i < arr.length; i++) {      

39.                count[digit(arr[i], d)] += 1;      

40.            }      

41.                 

48.            for (int i = 1; i < 10; i++) {      

49.                count[i] += count[i - 1];      

50.            }      

51.     

52.                 

62.            for (int i = arr.length - 1; i >= 0; i--) {//只能从最后一个元素往前处理      

63.                //for (int i = 0; i < arr.length; i++) {//不能从第一个元素开始循环      

64.                tmpArray[count[digit(arr[i], d)] - 1] = arr[i];      

65.                count[digit(arr[i], d)]--;      

66.            }      

67.     

68.            System.arraycopy(tmpArray, 0, arr, 0, tmpArray.length);      

69.        }      

70.        return arr;      

71.    }      

72.     

73.         

80.    public long[] radixSortDesc(long[] arr) {      

81.        for (int d = 1; d <= getMax(arr); d++) {       

82.            long[] tmpArray = new long[arr.length];      

83.            //位记数器，从第0个元素到第9个元素依次用来记录当前比较位是9的有多少个..是0的有多少个数      

84.            int[] count = new int[10];      

85.            //开始统计0有多少个，并存储在第9位，再统计1有多少个，并存储在第8位..依次统计      

86.            //到9有多少个，并存储在第0位      

87.            for (int i = 0; i < arr.length; i++) {      

88.                count[9 - digit(arr[i], d)] += 1;      

89.            }      

90.     

91.            for (int i = 1; i < 10; i++) {      

92.                count[i] += count[i - 1];      

93.            }      

94.     

95.            for (int i = arr.length - 1; i >= 0; i--) {      

96.                tmpArray[count[9 - digit(arr[i], d)] - 1] = arr[i];      

97.                count[9 - digit(arr[i], d)]--;      

98.            }      

99.     

100.            System.arraycopy(tmpArray, 0, arr, 0, tmpArray.length);      

101.        }      

102.        return arr;      

103.    }      

104.     

105.    private int getMax(long[] array) {      

106.        int maxlIndex = 0;      

107.        for (int j = 1; j < array.length; j++) {      

108.            if (array[j] > array[maxlIndex]) {      

109.                maxlIndex = j;      

110.            }      

111.        }      

112.        return String.valueOf(array[maxlIndex]).length();      

113.    }      

114.     

115.    public static void main(String[] args) {      

116.        long[] ary = new long[] { 123, 321, 132, 212, 213, 312, 21, 223 };      

117.        RadixSort rs = new RadixSort();      

118.        System.out.println("升- " + Arrays.toString(rs.radixSortAsc(ary)));      

119.     

120.        ary = new long[] { 123, 321, 132, 212, 213, 312, 21, 223 };      

121.        System.out.println("降- " + Arrays.toString(rs.radixSortDesc(ary)));      

122.    }      

123.}