优先级队列(java.util.PriorityQueue<E>)

实现方式的选择？

1，  用链表实现，插入数据以常数时间，但是访问最小（大）项要对链表进行线性扫描。若保持链表的有序性，访问访问最小（大）项以常数时间，但是插入确实线性时间。

2，  用二叉堆实现，具有这些优点（1）通过简单的数组实现，（2）最坏的情况，以O（logN）时间inser和deleteMin，（3）常数平均时间insert，最坏情况下常数时间findMin；

 二叉堆的介绍：

二叉堆：是一颗完全二叉树，可以用数组来表示，父亲在，左孩子在位置2i，右孩子在2i+1处。（为了满足这个条件，我们将数组0位置放空，从一开始存数）

最小（大）堆：父亲节点的数永远小（大）于孩子的数；

 

二叉堆插入操作如下图所示：（抄网上的图哈）

向上过滤的策略，就是将要插入的元素放在下一个可用的位置，然后不断地与父亲节点比较，一直向上冒，知道父节点的值小于它（针对最小堆而言）或为空；代码如下所示：

 public boolean add(AnyType x){
    	if(currentSize + 1 == array.length){
    		doubleArray();
    	}2
    	int hole = ++currentSize;
    	array[0] = x;                 //暂时保存该插入值
    	for(;array[hole/2].compareTo(x)>0;hole=hole/2){
    		array[hole]=array[hole/2];
    	}
    	array[hole] = x;
    	return true;
}

显然插入所需的时间为：O(logN)

 

删除操作：(抄网上的图，做些更改)

向下过滤的策略，取出根节点的数，取出数组最后的元素X填补根节点的空缺。开始向下过滤。根节点的数与两个孩子比较获取其最小值来交换位置，依次类推，直到父节点的值小于两个孩子的值。

//代码如下所示：

public AnyType remove(){
    	AnyType minItem = array[1];
    	//将最后一个元素填补根节点的空缺
    	array[1] = array[currentSize - 1];
    	//从下标1（即根节点）开始向下过滤
    	percolateDown(1);
    	return minItem;
    }
    
    public boolean percolateDown(int i){
    	int child;
    	AnyType x = array[i];
    	for(;2i<=array.length;i=child){
    		child = 2*i;
    		//先从两个孩子中选取较小的孩子（如果只有一个孩子，那么跳过）；
    		if(child != currentSize && array[child+1].compareTo(array[child])<0){
    			child++;
    		}
    		if(array[child].compareTo(array[i])<0){
    			array[i] = array[child];
    			array[child] = x;
    		}else{
    			break;
    		}
    	}
    }

显然deleteMin所需的时间为：O(logN)

 

buildHeap(构造堆)操作：

         对所有的父节点（编号由大到小的）调用percolateDown，向下过滤，公共需要调用currentSize/2次数；

         代码如下所示：

Private void buildHeap(){
	For(int i= currentSize/2;i>0;i--){
		percolateDown(i);
}
}

所需的时间是线性的O(N)（证明：略）

 

Java.util.Queue类，队列中的元素必须实现Comparator接口，否则会出错，源码如下所示（截取了部分对分析有用的代码）：

public class PriorityQueue<E> extends AbstractQueue<E>
    implements java.io.Serializable {
	//默认的队列的容量大小
    private static final int DEFAULT_INITIAL_CAPACITY = 11;
    //该数组用来保存数据的哈
    private transient Object[] queue;
    //该队列当前的数据的多少
    private int size = 0;
    //保存比较的对象
    private final Comparator<? super E> comparator;
    //队列的最大长度，每次add数据的时候，若队列满了会自动扩展，MAX_ARRAY_SIZE为数组的最大长度
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    public PriorityQueue() {
        this(DEFAULT_INITIAL_CAPACITY, null);
    }

    public PriorityQueue(int initialCapacity) {
        this(initialCapacity, null);
    }

    public PriorityQueue(int initialCapacity,
                         Comparator<? super E> comparator) {
        if (initialCapacity < 1)
            throw new IllegalArgumentException();
        this.queue = new Object[initialCapacity];
        this.comparator = comparator;
    }

  
    public boolean add(E e) {
        return offer(e);
    }

    public boolean offer(E e) {
        if (e == null)
            throw new NullPointerException();
        modCount++;//这个可以暂时不需要管它（用来记录更改的次数）
        int i = size;
        if (i >= queue.length)
            grow(i + 1); //队列满了，grow函数进行扩展
        size = i + 1;
        if (i == 0)
            queue[0] = e;
        else
            siftUp(i, e);//向上过滤哈。。
        return true;
    }
    
    
    public E poll() {
        if (size == 0)
            return null;
        int s = --size;
        modCount++;
        E result = (E) queue[0];
        E x = (E) queue[s];
        queue[s] = null;
        if (s != 0)
            siftDown(0, x);//向下过滤
        return result;
    }

    
    
    private void siftUp(int k, E x) {
        if (comparator != null)
            siftUpUsingComparator(k, x);
        else
            siftUpComparable(k, 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;
    }

    private void siftUpUsingComparator(int k, E x) {
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = queue[parent];
            if (comparator.compare(x, (E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = x;
    }
}

到此，基本介绍完毕，写了下如何用queue的代码，如下所示：

package jihe;

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;

public class PriorityQueueTest{

	public static void main(String[] args) {	
		//自然顺序排序
		Queue q = new PriorityQueue();
		for(int i=10;i>0;i--){
			q.add(i);
		}
		while(!q.isEmpty()){
			System.out.print(q.remove()+" ");
		}
		System.out.println();
		//根据类本身提供的compareTo方法排序
		Queue<person> q1 = new PriorityQueue<person>();
		for(int i=0;i<10;i++){
			q1.add(new person(i));
		}
		while(!q1.isEmpty()){
			System.out.print(q1.remove().height+" ");
		}
		System.out.println();
		//由Comparator提供的排序哈
		Queue<person> q2 = new PriorityQueue<person>(10,new xx());
		for(int i=0;i<10;i++){
			q2.add(new person(i));
		}
		while(!q2.isEmpty()){
			System.out.print(q2.remove().height+" ");
		}
	}
}
class person implements Comparable<person>{
	
	public int height;//懒得提供公有的方法哈，定义为公有的变量。。。见谅哈
	public person(int height){
		this.height = height;
	}
	@Override
	public int compareTo(person o) {
		// TODO Auto-generated method stub
		if(this.height < o.height){
			return -1;
		}
		return 1;
	}
}
class xx implements Comparator<person>{

	@Override
	public int compare(person o1, person o2) {
		// TODO Auto-generated method stub
		if(o1.height>o2.height){
			return -1;
		}
		return 1;
	}
	
}

输出结果：

1 2 3 4 5 6 7 8 9 10 
0 1 2 3 4 5 6 7 8 9 
9 8 7 6 5 4 3 2 1 0