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

原创 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");

    }
}


最小生成树 Prim以及Kruskal算法及效率解析

生成树:       一个有 n 个结点的连通图的生成树是原图的极小连通子图,且包含原图中的所有 n 个结点,并且有保持图连通的最少的边。 最小生成树:    在一给定的无向图G = (V, ...
  • wr132
  • wr132
  • 2015年02月01日 19:57
  • 1648

高效定时器:时间轮和时间堆

游戏后台之高效定时器-时间轮 原文地址:http://blog.csdn.net/soft2967/article/details/9274691 高性能定时器 定时器的结构有多种,比如链表...
  • yang_chen_shi_wo
  • yang_chen_shi_wo
  • 2015年06月12日 09:47
  • 1801

【算法】堆,最大堆(大顶堆)及最小堆(小顶堆)的实现

转:http://blog.csdn.net/cdnight/article/details/11650983 此坑待埋。 点击打开漫谈经典排序算法:一、从简单选择排序到堆排序的深度解...
  • chen_lin111
  • chen_lin111
  • 2016年01月07日 17:12
  • 7828

利用最小堆实现哈夫曼树

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

最小堆的基本操作

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

二叉堆:最小堆

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

代码c++ 最大堆最小堆

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

最小堆 实现的霍夫曼编码

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

最小堆的实现和操作

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

最小堆 源代码

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

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