為什么我的排序程序這么慢？ （Java中的基數/存儲桶排序）

Question

這是一個基數/存儲桶排序混合體，硬編碼為9位數字。 我的quicksort程序對10m數字進行排序的速度是原來的兩倍。 我已經驗證了輸出是正確的，只是速度很慢。

碼：

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    ArrayList<Integer> inputs = new ArrayList<>();
    while (in.hasNext()) {
        inputs.add(in.nextInt());
    }
    radixSort(inputs);
    //System.out.print(toString(radixSort(inputs)));
}

public static ArrayList<Integer> radixSort(ArrayList<Integer> a) {
    for (int i = 1; i <= 9; i++) {
        a = bucketSort(a, i);
    }
    return a;
}

public static ArrayList<Integer> bucketSort(ArrayList<Integer> a, int index) {
    // Creates buckets
    ArrayList<ArrayList<Integer>> b = new ArrayList<ArrayList<Integer>>();
    for (int i = 0; i < 10; i++) {
        b.add(new ArrayList<Integer>());
    }
    // Sorts into buckets
    for (int i = 0; i < a.size(); i++) {
        b.get(key(a.get(i), index)).add(a.get(i));
    }
    // Concatenates buckets
    ArrayList<Integer> c = new ArrayList<>();
    for (int i = 0; i < b.size(); i++) {
        c.addAll(b.get(i));
    }
    return c;
}

// Takes an integer and index and returns digit at index
public static int key(int num, int ind) {
    int digit = num / (int)Math.pow(10, ind - 1);
    digit = digit % 10;
    return (int)digit;
}

public static String toString(ArrayList<Integer> a){ 
    StringBuilder s = new StringBuilder();
    for (int i = 0; i < a.size(); i++){
        s.append(String.format("%09d\n", a.get(i)));
    }
    return s.toString();
}

Answer 1

速度慢的主要原因是一次將一個整數附加到每個存儲桶數組，必須再次附加以連接存儲桶，這涉及動態擴展數組。

最低有效位數的第一存儲桶排序的計數變化對與原始數組大小相同的第二數組進行一次分配。 對於9位數字的示例，它可以為每個數字生成“ 0”，“ 1”，...“ 9”的出現次數計數，然后將計數轉換為每個變量大小開頭的起始索引桶，無需級聯。 對於9位數的示例，矩陣[9] [10]可用於計數/索引，因此僅一次通過即可生成矩陣。

維基文章：

http://en.wikipedia.org/wiki/Counting_sort

示例C ++代碼使用字節大小的“數字”對32位無符號整數數組進行排序，因此計數/索引矩陣為[4] [256]。 唯一的C ++部分是std :: swap（），否則為C代碼。

typedef unsigned int uint32_t;

//  a is input array, b is working array
uint32_t * RadixSort(uint32_t * a, uint32_t *b, size_t count)
{
size_t mIndex[4][256] = {0};            // count / index matrix
size_t i,j,m,n;
uint32_t u;
    for(i = 0; i < count; i++){         // generate histograms
        u = a[i];
        for(j = 0; j < 4; j++){
            mIndex[j][(size_t)(u & 0xff)]++;
            u >>= 8;
        }       
    }
    for(j = 0; j < 4; j++){             // convert to indices
        m = 0;
        for(i = 0; i < 256; i++){
            n = mIndex[j][i];
            mIndex[j][i] = m;
            m += n;
        }       
    }
    for(j = 0; j < 4; j++){             // radix sort
        for(i = 0; i < count; i++){     //  sort by current lsb
            u = a[i];
            m = (size_t)(u>>(j<<3))&0xff;
            b[mIndex[j][m]++] = u;
        }
        std::swap(a, b);                //  swap ptrs
    }
    return(a);
}