PriorityQueue的小结_JAVA_编程开发_程序员俱乐部

在队列中,一般都是先进先出的,但其实java中提供了可以用户自定义权重的优先级队列.
本文小结一下:
 
PriorityQueue
PriorityQueue是个基于优先级堆的极大优先级队列。
此队列按照在构造时所指定的顺序对元素排序，既可以根据元素的自然顺序来指定排序（参阅 Comparable），
也可以根据 Comparator 来指定，这取决于使用哪种构造方法。优先级队列不允许 null 元素。
依靠自然排序的优先级队列还不允许插入不可比较的对象（这样做可能导致 ClassCastException）。
此队列的头是按指定排序方式的最小元素。如果多个元素都是最小值，则头是其中一个元素——选择方法是任意的。
队列检索操作 poll、remove、peek 和 element 访问处于队列头的元素。
优先级队列是无界的，但是有一个内部容量，控制着用于存储队列元素的数组的大小。
它总是至少与队列的大小相同。随着不断向优先级队列添加元素，其容量会自动增加。无需指定容量增加策略的细节。
注意1：该队列是用数组实现，但是数组大小可以动态增加，容量无限。
注意2:此实现不是同步的。不是线程安全的。如果多个线程中的任意线程从结构上修改了列表， 则这些线程不应同时访问 PriorityQueue 实例，这时请使用线程安全的PriorityBlockingQueue 类。
注意3:不允许使用 null 元素。
注意4：此实现为插入方法（offer、poll、remove() 和 add 方法）提供 O(log(n)) 时间；
为 remove(Object) 和 contains(Object) 方法提供线性时间；
为检索方法（peek、element 和 size）提供固定时间。
注意5:方法iterator()中提供的迭代器并不保证以有序的方式遍历优先级队列中的元素。
至于原因可参考下面关于PriorityQueue的内部实现
如果需要按顺序遍历，请考虑使用 Arrays.sort(pq.toArray())。
注意6：可以在构造函数中指定如何排序。如：
PriorityQueue()
          使用默认的初始容量（11）创建一个 PriorityQueue，并根据其自然顺序来排序其元素（使用 Comparable）。
PriorityQueue(int initialCapacity)
          使用指定的初始容量创建一个 PriorityQueue，并根据其自然顺序来排序其元素（使用 Comparable）。
PriorityQueue(int initialCapacity, Comparator<? super E> comparator)
          使用指定的初始容量创建一个 PriorityQueue，并根据指定的比较器comparator来排序其元素。
注意7:此类及其迭代器实现了 Collection 和 Iterator 接口的所有可选 方法。
PriorityQueue的内部实现
PriorityQueue对元素采用的是堆排序，头是按指定排序方式的最小元素。堆排序只能保证根是最大（最小），整个堆并不是有序的。
方法iterator()中提供的迭代器可能只是对整个数组的依次遍历。也就只能保证数组的第一个元素是最小的。


例子:
 
public static void main(String[] args) {
        PriorityQueue<String> pq = new PriorityQueue<String>();
        pq.add("dog");
        pq.add("apple");
        pq.add("fox");
        pq.add("easy");
        pq.add("boy");
       
        while (!pq.isEmpty()) {
         System.out.print("left:");
            for (String s : pq) {
                System.out.print(s + " ");
            }
            System.out.println();
            System.out.println("poll(): " + pq.poll());
        }
    }
输出的结果如下：
left:apple boy fox easy dog
poll(): apple
left:boy dog fox easy
poll(): boy
left:dog easy fox
poll(): dog
left:easy fox
poll(): easy
left:fox
poll(): fox
可以看到，虽然PriorityQueue保持了队列顶部元素总是最小，但内部的其它元素的顺序却随着元素的减少始终处于变化之中。
察看源代码来一探究竟。从Netbeans中非常方便的连接到PriorityQueue的add函数实现，
最终跟踪到函数private void siftUpComparable(int k, E x)，定义如下：
     private void siftUpComparable(int k, E x) {
        Comparable<? super E> key = (Comparable<? super E>) x;
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = queue[parent];
            if (key.compareTo((E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = key;
    }
相对于add的操作，该函数的入口参数k是指新加入元素的下标，而x 就是新加入的元素。
乍一看，这个函数的实现比较令人费解，尤其是parent的定义。通过进一步分析了解到，
PriorityQueue内部成员数组 queue其实是实现了一个hashu.html" target="_blank">二叉树的数据结构，这棵二叉树的根节点是queue[0]，
左子节点是queue[1]，右子节点是queue[2]，而 queue[3]又是queue[1]的左子节点，依此类推，给定元素queue，
该节点的父节点是queue[(i-1)/2]。因此 parent变量就是对应于下标为k的节点的父节点。
弄清楚了这个用数组表示的二叉树，就可以理解上面的代码中while 循环进行的工作是，
当欲加入的元素小于其父节点时，就将两个节点的位置交换。这个算法保证了如果只执行add操作，那么queue这个二叉树是有序的：
该二叉树中的任意一个节点都小于以该节点为根节点的子数中的任意其它节点。这也就保证了queue[0]，即队顶元素总是所有元素中最小的。
需要注意的是，这种算法无法保证不同子树上的两个节点之间的大小关系。举例来说，queue[3]一定会小于queue[7]，但是未必会小于queue[9]，因为queue[9]不在以queue[3]为根节点的子树上。
弄清楚了add的操作，那么当队列中的元素有变化的时候，对应的数组queue又该如何变化呢？察看函数poll()，
最终追中到函数private E removeAt(int i)，代码如下：
     private E removeAt(int i) {
        assert i >= 0 && i < size;
        modCount++;
        int s = --size;
        if (s == i) // removed last element
            queue = null;
        else {
            E moved = (E) queue[s];
            queue[s] = null;
            siftDown(i, moved);
            if (queue == moved) {
                siftUp(i, moved);
                if (queue != moved)
                    return moved;
            }
        }
        return null;
    }
这个函数的实现方法是，将队尾元素取出，插入到位置i，替代被删除的元素，然后做相应的调整，保证二叉树的有序，
即任意节点都是以它为根节点的子树中的最小节点。进一步的代码就留给有兴趣的读者自行分析，
要说明的是，对于 queue这样的二叉树结构有一个特性，即如果数组的长度为length，
那么所有下标大于length/2的节点都是叶子节点，其它的节点都有子节点。
总结：可以看到这种算法的实现，充分利用了树结构在搜索操作时的优势，效率又高于维护一个全部有序的队列


------------------------------------------------------------------------
总结:其实上面說了这么多,就是在說，在add,poll的时候都是在使用堆排序！建立的是小堆！
再看例子：

class="java" name="code">
public class PriorityQueueDemo {
   public static void main(String args[]) {
      // create priority queue
      PriorityQueue < Integer >  prq = new PriorityQueue < Integer > (); 
       
      // insert values in the queue
      for ( int i = 3; i  <  10; i++ ){  
         prq.add (new Integer (i)) ; 
      }
      
      System.out.println ( "Initial priority queue values are: "+ prq);
      
      // get the head from the queue
      Integer head = prq.poll();
      
      System.out.println ( "Head of the queue is: "+ head);
      
      System.out.println ( "Priority queue values after poll: "+ prq);
   }
}

输出的是：

Initial priority queue values are: [3, 4, 5, 6, 7, 8, 9]
Head of the queue is: 3
Priority queue values after poll: [4, 6, 5, 9, 7, 8]

为什么是4, 6, 5, 9, 7, 8呢？其实就是在3出队后，对剩下的4，5，6，7，8，9进行
重新建立小堆！

----------------------------------------------------------------------------
再来看自定义的comparator比较器
public static void main(String[] args) {
// TODO Auto-generated method stub
Queue<Integer> qi = new PriorityQueue<Integer>();

    qi.add(5);
    qi.add(2);
    qi.add(1);
    qi.add(10);
    qi.add(3);

    while (!qi.isEmpty()){
      System.out.print(qi.poll() + ",");
    }
    System.out.println();
    System.out.println("-----------------------------");

    Comparator<Integer> cmp;
    cmp = new Comparator<Integer>() {
      public int compare(Integer e1, Integer e2) {
        return e2 - e1;
      }
    };
    Queue<Integer> q2 = new PriorityQueue<Integer>(5,cmp);
    q2.add(2);
    q2.add(8);
    q2.add(9);
    q2.add(1);
    while (!q2.isEmpty()){
      System.out.print(q2.poll() + ",");
    }


}

输出的是：9 8 2 1

---------------------------------------------------------------------------
还可以用这个轻松解决TOP K问题，两个不错的资料参考：
1 http://my.oschina.net/leejun2005/blog/135085

2 http://marvin-space.info/blog/algo_priority-queue/