位图排序

应用位图的排序

引言

生活中我们不可避免的会遇到大数据排序问题，这里是对《编程珠玑》中第1章中所描述的一类排序需求的简单手记。

背景

类似对存储7位电话号码的数据库进行整理，即对不超过一千万个不重复数据进行排序，限制内存占用1M和时间占用小于10s。

预备

时间

对于一趟循环即时间复杂度为O(n)的程序需要至少一千万此操作，嵌套一层循环则为O(n^2)，即一千万的平方次，显然是不现实的。所以最佳方案是一趟排序即完成。

内存

在磁盘中排序显然没有全部读入内存中快速，所以要考虑的是如何在1M内存入最多的数据。Jon Bentley给出的思路令我非常惊奇，利用位图存储数据，即用一位数来表示一个7位数据。

位图表示数据

用一个20位长的字符串来表示一个所有元素都小于20的非负整数集，例如可用如下字符串来表示集合{1，2，3，5，8，13}

0 1 1 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 0 0

代表集合中数据的位置置1，其余位置置0。

思路

用一个10000000位数组对从0000000~9999999的不超过一千万个数进行按位存储，顺序输出即为排序后的数据。
伪代码

define m 10000000
//第一步，置零
for i = [0,m]
    bit[i] = 0

//第二步，置数
for each i in the input file
    bit[i] = 1

//第三步，取数
for i = [0,m]
    if (bit[i] == 1)
        print i

实践

随机生成一千万个数

Random random = new Random();
for (int i = 0; i < bit; i++) {
	arr[i] = -1;
	arr[i] = random.nextInt(bit-1);
	mSort[i] = false;
}

排序

for(int i = 0; i< bit; i++){
	if(arr[i] != -1)
	mSort[arr[i]] = true;
}

输出

for(int i=0 ; i<99;i++){
	if(mSort[i])
		System.out.println(i);
}

完整实例

package bitmapsort;

import java.util.Random;

public class BitMap {
	final int bit = 10000000;
	private int[] arr = new int[bit];
	private boolean[] mSort = new boolean[bit];
	

	public BitMap() {
		// TODO Auto-generated constructor stub
		Random random = new Random();
		for (int i = 0; i < bit; i++) {
			arr[i] = -1;
			arr[i] = random.nextInt(bit-1);
			mSort[i] = false;
		}
	}

	public void sort() {
		for(int i = 0; i< bit; i++){
			if(arr[i] != -1)
			mSort[arr[i]] = true;
		}
	}
	
	
	public void print(){
		for(int i = 0 ; i< bit ;i++){
			if(mSort[i])
				System.out.println(i);
		}
	}
	
	public static void main(String[] args) {
		long time ;
		time = System.currentTimeMillis();
		BitMap BM = new BitMap();
		time = System.currentTimeMillis() - time;
		System.out.println("create time :"+time+"ms");
		
		
		//位图排序
		time = System.currentTimeMillis();
		BM.sort();
		time = System.currentTimeMillis() - time;
		System.out.println("bit sort time :"+time+"ms");
		
		
//		BM.print();
	}
}

运行

第一次运行

第二次运行

第三次运行

第四次运行

此时可看到，使用该算法排序不超过一千万个7位整数仅需不到80ms左右，非常惊艳。

分析

此算法的排序速度虽然很快，但是也有一个弊端，就是这一千万个数中不能出现相同数据，不然会出现数据丢失。适用范围有限。
那么如果改进一下呢？

改进

version 1.1

假设同一个数会存在至多128个，则可以使用byte[]。
代码修改略
实际测试中时间依然为70ms左右。

version 1.2

既然时间充足，如果取消内存限制的话，可以尝试更换为int[]，java中int的范围为“-2^32”到“232-1”，即“-2147483648”到“2147483647”。
此时足够处理一千个数都为同一个数的极限情况。
修改后的代码

public class BitMap {
	final int bit = 10000000;
	private int[] arr = new int[bit];
	private int[] mSort = new int[bit];

	public BitMap() {
		// TODO Auto-generated constructor stub
		Random random = new Random();
		for (int i = 0; i < bit; i++) {
			arr[i] = -1;
			arr[i] = random.nextInt(bit-1);
			mSort[i] = 0;
		}
	}

	public void sort() {
		for(int i = 0; i< bit; i++){
			if(arr[i] != -1)
			mSort[arr[i]] ++;
		}
	}

	public void print(){
		for(int i = 0 ; i < bit ;i++){
			if(mSort[i] > 0)
				System.out.println(i+"*"+mSort[i]);
		}
	}