Bitmap排序

Bitmap排序

bitmap排序：开辟数据最大值长度的bit数组记录数据是否存在，存在为1，不存在为0，这样可以一趟循环，就可以获取数据的顺序。可以在线性时间处理海量大数据,数据不能重复。

package com.marving.acm.sort;
import static com.marving.util.Print.print;

/**
 * 
 * @title: bitmap排序,线性时间处理海量大数据,数据不能重复
 * @author: Marvin Guo
 * @create time: 2016年12月29日
 */
public class BitSort extends SortingAlgorithm{

    private final int LEN_INT = 32;

    private final int mmax = 9000000;
    private final int mmin = 0;
    private final int N = mmax - mmin + 1;

    // 默认p和r无作用
    @Override
    public void sort(int[] numbers, int p, int r) {
        int[] bitArray = setBit(numbers);
        int index = 0;
        for (int i = 0; i < N; i++) {
            if (getBit(bitArray, i) != 0) {
                numbers[index++] = i + mmin;
            }
        }
    }

    //获取数字k在位数组中是否存在，返回所在位
    public int getBit(int[] bitArray, int k) {
        return bitArray[k/LEN_INT]&1<<(k%LEN_INT);
    }

    //设置位数组:
    public int[] setBit(int[] array) {
        int bit_arr_len = N / LEN_INT + 1;
        int[] bitArray = new int[bit_arr_len];

        for(int i = 0; i < array.length; i++){
            int num = array[i] - mmin;
            bitArray[num/LEN_INT] |= 1<<(num%LEN_INT);
        }
        return bitArray;

    }

    public static void main(String[] args) {

        int[] a={5,4,1,9,13,100,96,43,68,2,12,2,2};
        BitSort bsort = new BitSort();
        bsort.sort(a);

        print(a);
        bsort.getSortTime(a);
    }

}

通过int数组来存储bit，每个int值可存储32个bit位。具体转换关系如下：

1. 求十进制0-N对应在数组a中的下标：
   十进制0-31，对应在a[0]中，先由十进制数n转换为与32的余可转化为对应在数组a中的下标。比如n=24,那么 n/32=0，则24对应在数组a中的下标为0。又比如n=60,那么n/32=1，则60对应在数组a中的下标为1，同理可以计算0-N在数组a中的下标。

2. 求0-N对应0-31中的数：
   十进制0-31就对应0-31，而32-63则对应也是0-31，即给定一个数n可以通过模32求得对应0-31中的数。

3. 利用移位0-31使得对应32bit位为1.

备注 排序抽象类说明如下：

package com.marving.acm.sort;

/**
 * 
 * @title: 排序抽象类
 * @author: Marvin Guo
 * @create time: 2016年12月28日
 */
public abstract class SortingAlgorithm {

    public void sort(int[] numbers){
        sort(numbers,0,numbers.length-1);
    };

    /**
     * sort 抽象方法
     * @param numbers
     */
    public abstract void sort(int[] numbers,int p,int r);

    /**
     * 两个数字交换
     * @param numbers
     * @param i
     * @param j
     */
    protected void swap(int[] numbers, int i, int j) {
        int temp = numbers[i];
        numbers[i] = numbers[j];
        numbers[j] = temp;
    }

    /**
     * 验证输入
     * @param numbers
     */
    protected void validateInput(int[] numbers) {
        if (numbers == null) {
            throw new IllegalArgumentException("You can't pass a null instance as parameter.");
        }
    }

    /**
     * 获取排序时间
     * @param numbers
     */
    public void getSortTime(int[] numbers) {
        //
        long startTime = System.currentTimeMillis();
        this.sort(numbers);
        //
        long endTime = System.currentTimeMillis();
        long usedTime = endTime - startTime;
        System.out.println(this.getClass().getSimpleName() + " 用时：" + usedTime + "ms");
    }

}