Java 为什么位图排序不会比合并排序快很多?
我正在编写Peals程序,第一篇文章是关于在已知范围内对数字进行排序的。作为一个聪明的解决方案,他们提供了一个位图的实现,将输入文件中的所有数字设置为位图中的一,然后简单地对其进行迭代以打印结果。假设这应该比更传统的排序算法(如quicksort或mergesort)快得多 为了测试这一点,我自己用Java编写了位图排序。当我发现使用merge-sort的Unix-sort命令仍然快得多时,我并不感到惊讶。我认为这是因为它是用C编写的,可能是一些非常聪明的人对它进行了高度优化 于是,我编写了自己的合并排序,也是用Java编写的。令我惊讶的是,我的BitmapSort速度更快,但只差一点点。对于一个非常大的输入文件(+-800000个整数),bitmapsort的速度仅快30% 以下是我的位图排序和位图实现:Java 为什么位图排序不会比合并排序快很多?,java,algorithm,bitmap,big-o,mergesort,Java,Algorithm,Bitmap,Big O,Mergesort,我正在编写Peals程序,第一篇文章是关于在已知范围内对数字进行排序的。作为一个聪明的解决方案,他们提供了一个位图的实现,将输入文件中的所有数字设置为位图中的一,然后简单地对其进行迭代以打印结果。假设这应该比更传统的排序算法(如quicksort或mergesort)快得多 为了测试这一点,我自己用Java编写了位图排序。当我发现使用merge-sort的Unix-sort命令仍然快得多时,我并不感到惊讶。我认为这是因为它是用C编写的,可能是一些非常聪明的人对它进行了高度优化 于是,我编写了自己
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;
导入java.io.FileReader;
导入java.io.File;
类位图排序{
扫描仪sc;
BitmapSort()引发异常{
sc=新扫描仪(新文件(“numbers.txt”);
}
void start(){
位图映射=新位图(3000000);
while(sc.hasnetint()){
map.set(sc.nextInt());
}
对于(int i=0;i<3000000;i++){
if(地图isSet(i)){
系统输出打印LN(i);
}
}
}
公共静态void main(字符串[]args)引发异常{
新建BitmapSort().start();
}
}
类位图{
字节[]位;
整数大小;
位图(int n){
尺寸=n;
bits=新字节[(int)Math.ceil((double)n/(double)byte.SIZE)];
for(字节b:位){
b=0;
}
}
专用字符串toBinary(字节b){
返回String.format(Integer.toBinaryString(b&0xFF)).replace(“”,'0');
}
无效集(int i){
int index=i/Byte.SIZE;
位[索引]=(字节)((位[索引]|(字节))(1首先,编程珍珠(Programming Pearls)的文章是在内存层次结构的影响变得像今天这样严重之前撰写的。800K字节的映射添加了大量随机访问内存流量,很可能导致缓存未命中。Mergesorts往往具有良好的本地内存性能。我怀疑您的位集排序是IO限制的。它是如何实现的r格式化是否将所有数字读入内存,然后将性能计时到内存中的数据上?此外,我可以在您的实现中看到一些错误。for(Byte b:bits){b=0;}
并不像你想象的那样。它实际上对位绝对没有影响unset
正在执行一个切换而不是一个unset操作。谢谢!我的程序中没有使用unset操作,所以这不是一个真正的问题。构造函数中的for循环是不幸的,但与J一样也不应该是一个问题ava自动将字节初始化为0(对吗?)。通过先读入,然后进行基准测试,bitmapsort的速度大约快了54%,这是令人鼓舞的。尽管如此,我还是希望它更快…我确实看到了答案。但是,我有一些问题。为什么在java中使用BitSet来实现此目的时要创建位图。在构造函数中设置0的目的是什么。默认情况下,它是零?当你说它快了30%时-你是如何测量的?涉及哪些方法?在合并排序中没有文件读取(IO)但在位图排序中,您有IO操作。最后,您不需要检查每个位是否已设置。检查位集中的nextSetBit方法比您的有效得多。啊,很好!我没有想到。谢谢!@Gene-我不明白。这两种方法都创建数组[]80k。一个和另一个有何不同?在这两种方法中,他们都是使用索引访问数组。-为我的错误道歉ignorance@Mani位图方法从文件中读取随机整数,并在相应的位置设置一个位。由于输入是随机的,所以内存中的位置也是随机的。@Linus。在数组中设置随机数发生在n本地内存(RAM)是否会导致性能下降?(同意从文件部分读取。在本文中不应考虑这一点,因为我们正在比较排序算法而不是读取部分)。我认为这发生在O(1)中时间。谢谢。@Mani随机访问大块内存确实会导致程序运行速度比按顺序和/或本地访问慢得多。请阅读“内存层次结构”。当按本地和/或顺序访问时,现代内存的运行速度要快几个数量级。
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();
}
}