很高效的用于调度的最小堆

原创 2015年07月08日 17:28:13

摘自于Hadoop大量文件调度合并

public abstract class PriorityQueue<T> {

    private T[] heap;
    private int size;
    private int maxSize;

    protected abstract boolean lessThan(Object a, Object b);

    @SuppressWarnings("unchecked")
    protected final void initialize(int maxSize) {
        size = 0;
        int heapSize = maxSize + 1;
        heap = (T[]) new Object[heapSize];
        this.maxSize = maxSize;
    }

    public final void put(T element) {
        size++;
        heap[size] = element;
        upHeap();
    }

    /**
     * @param element
     * @return
     */
    public boolean insert(T element) {
        if (size < maxSize) {
            put(element);
            return true;
        } else if (size > 0 && !lessThan(element, top())) {
            heap[1] = element;
            adjustTop();
            return true;
        } else
            return false;
    }

    /**
     * @return
     */
    public final T top() {
        if (size > 0)
            return heap[1];
        else
            return null;
    }

    public final T pop() {
        if (size > 0) {
            T result = heap[1];
            heap[1] = heap[size];
            heap[size] = null;
            size--;
            downHeap();
            return result;
        } else
            return null;
    }

    public final void adjustTop() {
        downHeap();
    }

    public final int size() {
        return size;
    }

    public final void clear() {
        for (int i = 0; i <= size; i++)
            heap[i] = null;
        size = 0;
    }

    private final void upHeap() {
        int i = size;
        T node = heap[i];
        int j = i >>> 1;
        while (j > 0 && lessThan(node, heap[j])) {
            heap[i] = heap[j];
            i = j;
            j = j >>> 1;
        }
        heap[i] = node;
    }

    private final void downHeap() {
        int i = 1;
        T node = heap[i];
        int j = i << 1;
        int k = j + 1;
        if (k <= size && lessThan(heap[k], heap[j])) {
            j = k;
        }
        while (j <= size && lessThan(heap[j], node)) {
            heap[i] = heap[j];
            i = j;
            j = i << 1;
            k = j + 1;
            if (k <= size && lessThan(heap[k], heap[j])) {
                j = k;
            }
        }
        heap[i] = node;
    }

    /**
     * Test
     *
     * @param args
     */
    public static void main(String[] args) {
        int max = 10000000;
        long s = System.currentTimeMillis();
        Random r = new Random();
        System.out.println("---------- 有序数据结构比较 ----------");

        //最小堆
        PriorityQueue<Integer> queue = new PriorityQueue<Integer>() {
            @Override
            protected synchronized boolean lessThan(Object a, Object b) {
                Integer a1 = (Integer) a;
                Integer a2 = (Integer) b;
                return a1 > a2;
            }
        };
        queue.initialize(max);
        for (int i = 0; i < max; i++) {
            queue.insert(r.nextInt());
        }
        while (queue.size() > 0) {
            queue.pop();
        }
        System.out.println("最小堆性能:" + (System.currentTimeMillis() - s) + "ms");

        s = System.currentTimeMillis();
        List<Integer> list = new ArrayList<Integer>(max);
        for (int i = 0; i < max; i++) {
            list.add(r.nextInt());
        }
        Collections.sort(list);
        System.out.println("归并性能:" + (System.currentTimeMillis() - s) + "ms");

        s = System.currentTimeMillis();
        ConcurrentSkipListSet<Integer> skiptable = new ConcurrentSkipListSet<Integer>();
        for (int i = 0; i < max; i++) {
            skiptable.add(r.nextInt());
        }
        System.out.println("跳跃表性能:" + (System.currentTimeMillis() - s) + "ms");

        s = System.currentTimeMillis();
        TreeSet<Integer> rbt = new TreeSet<Integer>() {
            @Override
            public synchronized boolean add(Integer integer) {
                return super.add(integer);
            }
        };
        for (int i = 0; i < max; i++) {
            rbt.add(r.nextInt());
        }
        System.out.println("红黑树性能:" + (System.currentTimeMillis() - s) + "ms");

    }
}


相关文章推荐

利用最小堆实现哈夫曼树

  • 2015年11月17日 14:31
  • 6KB
  • 下载

最小堆的基本操作

  • 2013年03月13日 22:39
  • 244KB
  • 下载

[数据结构]最小堆的类模板实现

堆数据结构是一种数组对象,它可以被视为一科完全二叉树结构。它的特点是父节点的值大于(小于)两个子节点的值(分别称为最大堆和最小堆)。它常用于管理算法执行过程中的信息,应用场景包括堆排序,优先队列等。1...

代码c++ 最大堆最小堆

  • 2013年01月03日 09:40
  • 28KB
  • 下载

二叉堆:最小堆

  • 2014年07月08日 17:08
  • 5KB
  • 下载

Java最小堆解决TopK问题

TopK问题是指从大量数据(源数据)中获取最大(或最小)的K个数据。 TopK问题是个很常见的问题:例如学校要从全校学生中找到成绩最高的500名学生,再例如某搜索引擎要统计每天的100条搜索次数最多...

最小堆 实现的霍夫曼编码

  • 2016年12月22日 11:17
  • 6KB
  • 下载

最小堆的实现和操作

  • 2016年12月03日 19:47
  • 5KB
  • 下载

最小的K个数 (冒泡和最小堆)

问题:最小的K个数 输入n个整数,找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字,则最小的4个数字是1,2,3,4,。 - 方法一(冒泡排序k趟) 思路:冒泡排...
  • hyqsong
  • hyqsong
  • 2015年10月31日 08:54
  • 291

最小堆 源代码

  • 2013年03月30日 22:55
  • 2KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:很高效的用于调度的最小堆
举报原因:
原因补充:

(最多只允许输入30个字)