为什么我的位图排序没有无限快于我的合并排序？

Question

我正在研究 Programming Peals，第一篇文章涉及对已知范围内的数字进行排序。作为一个聪明的解决方案，他们提供实现位图，将输入文件中的所有数字设置为位图中的一个，然后简单地对其进行迭代以打印结果。假设这应该比更传统的排序算法（如快速排序或合并排序）快得多。

为了测试这一点，我自己用 Java 编写了位图排序。当我发现使用归并排序的 Unix 排序命令仍然快得多时，我并没有太惊讶。我将此归因于它是用 C 编写的，并且可能由一些非常聪明的人进行了高度优化。

所以，然后我编写了自己的归并排序，也是用 Java 编写的。令我惊讶的是，我的 BitmapSort 更快，但只有一点点。对于非常大的输入文件（+-800000 个整数），位图排序仅快 30% 左右。

这是我的位图排序和位图实现：

import java.util.Scanner;
import java.io.FileReader;
import java.io.File;

class BitmapSort {
    Scanner sc;

    BitmapSort() throws Exception {
        sc = new Scanner(new File("numbers.txt"));
    }

    void start() {
        BitMap map = new BitMap(3000000);
        while (sc.hasNextInt()) {
            map.set(sc.nextInt());
        }
        for (int i = 0; i < 3000000; i++) {
            if (map.isSet(i)) {
                System.out.println(i);
            }
        }
    }

    public static void main(String[] args) throws Exception {
        new BitmapSort().start();
    }
}


class BitMap {

    byte[] bits;
    int size;


    BitMap(int n) {
        size = n;
        bits = new byte[(int) Math.ceil((double) n / (double) Byte.SIZE)];
        for (Byte b : bits) {
            b = 0;
        }
    }

    private String toBinary(byte b) {
        return String.format(Integer.toBinaryString(b & 0xFF)).replace(' ', '0');
    }

    void set(int i) {
        int index = i / Byte.SIZE;
        bits[index] = (byte) ((bits[index] | (byte) (1 << (Byte.SIZE - 1 - (i % Byte.SIZE)))));
    }

    void unset(int i) {
        int index = i / Byte.SIZE;
        bits[index] = (byte) ((bits[index] ^ (byte) (1 << (Byte.SIZE - 1 - (i % Byte.SIZE)))));
    }

    boolean isSet(int i) {
        int index = i / Byte.SIZE;
        byte mask = (byte) ((bits[index] & (byte) (1 << (Byte.SIZE - 1 - (i % Byte.SIZE)))));
        return (bits[index] & mask) != 0;
    }

}

这是我的归并排序：

import java.util.Scanner;
import java.io.FileReader;
import java.io.File;

class MergeSort {
    Scanner sc;
    static int times;

    MergeSort() throws Exception {
        sc = new Scanner(new File("numbers.txt"));
        times = 0;
    }


    int[] mergeSort(int[] input) {
        if (input.length <= 1) {
            return input;
        }

        int middle = input.length / 2;

        int[] left = new int[middle];
        int[] right;
        if (input.length % 2 == 0) {
            right = new int[middle];
        } else {
            right = new int[middle + 1];
        }

        for (int i = 0; i < middle; i++) {
            left[i] = input[i];
        }
        for (int i = middle; i < input.length; i++) {
            right[i - middle] = input[i];
        }
        left = mergeSort(left);
        right = mergeSort(right);
        return merge(left, right);
    }

    int[] merge(int[] left, int[] right) {
        times++;
        int[] result = new int[left.length + right.length];
        int left_size = 0;
        int right_size = 0;
        int result_size = 0;
        while (left_size < left.length || right_size < right.length) {
            if (left_size < left.length && right_size < right.length) {
                if (left[left_size] <= right[right_size]) {
                    result[result_size] = left[left_size];
                    left_size++;
                    result_size++;
                } else {
                    result[result_size] = right[right_size];
                    right_size++;
                    result_size++;
                }
            } else if (left_size < left.length) {
                result[result_size] = left[left_size];
                left_size++;
                result_size++;
            } else if (right_size < right.length) {
                result[result_size] = right[right_size];
                right_size++;
                result_size++;
            }
        }
        return result;
    }

    void start() {
        int[] input = new int[838662];
        int i = 0;
        while (sc.hasNextInt()) {
            input[i] = sc.nextInt();
            i++;
        }


        int[] result = mergeSort(input);
        for (int j : result) {
            System.out.printf("%d\n", j);
        }
    }


    public static void main(String[] args) throws Exception {
        new MergeSort().start();
    }
}

输入文件包含0 和3000000 之间的整数，并包含838661 数字。 请原谅丑陋的编码风格，这只是为了快速比较。

提前致谢！ 问候， 莱纳斯

Answer 1

一方面，Programming Pearls 文章是在内存层次结构的影响变得像今天这样严重之前写的。 800K 字节的映射会增加大量随机存取内存流量，很可能会导致缓存未命中。合并排序往往具有良好的本地内存性能。