Java中优先级队列的基本知识

概念
队列（PriorityQueue）是一种先进先出的数据结构，但是有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列。在这种情况下，数据结构提供了两个最基本的操作，一个返回最高优先级对象，一个是添加新的对象，这种数据结构就是优先级队列。
PriorityQueue是线程不安全的，而PriorityBlockingQueue是线程安全的。
注意：
1.使用前必须先导入所对应的包；

import java.util.PriorityQueue;

2.PriorityQueue中放置的元素必须能够比较大小，不能插入无法比较的对象，否则会抛出ClassCastException异常；
3.不能插入null对象，否则会抛出NullPointerException异常；
4.没有容量限制，可以插入任意多个元素，其内部可以自动扩容;
5.插入和删除元素的时间复杂度为O(logN);
6.PriorityQueue底层使用了堆数据结构。
常用接口

• 构造方法
  

public static void testPriorityQueue1(){
        //1.构造一个空的优先级队列 注意:空的优先级队列，底层已经有了11个默认空间
        PriorityQueue<Integer> p1 = new PriorityQueue<>();
        //2.按照指定容量来进行构造
        //如果大概知道优先级队列要放多少元素，最好使用该种方式进行构造
        //不要使用空的进行构造，影响程序效率
        PriorityQueue<Integer> p2 = new PriorityQueue<>(20);
        //3.可以用一个集合来直接构造优先级队列，将来就会将集合中的元素放到优先级队列中
        List<Integer> l = new ArrayList<>();
        l.add(0);
        l.add(1);
        l.add(2);
        l.add(3);
        l.add(4);
        //使用list构造优先级队列时，并不是直接把元素拷贝进来，而是按照一定规则进行排列
        PriorityQueue<Integer> p3 = new PriorityQueue<>(l);
        System.out.println(p3.size());
    }

• 内部方法
  
  模拟实现

import java.util.Arrays;

interface Comp{
    public int compare(int left, int right);
}
class Less implements Comp{
    //0:left == right
    //>0:left > right
    //<0:left < right
    public int compare(int left, int right){
        return left - right;
    }
}

class Greater implements Comp{
    public int compare(int left, int right){
        return right - left;
    }
}

public class MyPriorityQueue {
    private int[] array;
    private int size;
    Comp compare = null;
    public MyPriorityQueue(Comp comp){
        //默认的构造方法，底层容量为11
        array = new int[11];
        size = 0;
        compare = comp;
    }
    public MyPriorityQueue(int initCapacity, Comp comp){
        if(initCapacity < 1){
            //标准库：抛出一个非法参数的异常
            initCapacity = 11;
        }
        array = new int[initCapacity];
        size = 0;
        compare = comp;
    }
    //标准库中没有该接口-->标准库中采用集合来构造优先级队列
    public MyPriorityQueue(int[] arr, Comp comp){
        array = new int[arr.length];
        for(int i = 0;i < arr.length;i++){
            array[i] = arr[i];
        }
        size = array.length;
        compare = comp;
        //将array中的元素进行调整，让其满足小堆的性质
        int node = (arr.length - 2) >> 1;
        for(;node >= 0;node--){
            shiftDown(node);
        }
    }
    int peek(){
        //标准库中，如果优先级队列是空，无法获取堆顶元素，返回null
        return array[0];
    }
    boolean offer(int x){
        //检测是否需要扩容
        if(size >= array.length){
            grow();
        }
        //将x尾插到数组中
        array[size++] = x;
        shiftUp(size - 1);
        return true;
    }
    int poll(){
        int ret = array[0];
        swap(0,size - 1);
        size--;
        shiftDown(0);
        return ret;
    }
    boolean isEmpty(){
        return 0 == size;
    }

    void clear(){
        size = 0;
    }
    private void shiftDown(int parent) {
        int size = array.length;
        //使用child标记parent的左孩子
        //默认标记左孩子，因为parent可能只有左孩子没有右孩子
        int child = parent * 2 + 1;
        while (child < array.length) {
            //child标记较小的孩子
            //利用左右孩子进行比较时，必须保证右孩子存在
            //if (child + 1 < size && array[child + 1] > array[child]) {
            if(child + 1 < size && compare.compare(array[child + 1], array[child]) > 0){
                child += 1;
            }
            //检测双亲是否比较小的孩子大
            //if (array[child] > array[parent]) {
            if(compare.compare(array[child],array[parent]) > 0){
                //说明双亲不满足小堆的性质，将child与parent的元素交换
                swap(child, parent);
                //parent较大的元素向下移动，可能会导致子树不满足堆的性质
                parent = child;
                child = parent * 2 + 1;
            } else {
                //双亲已经满足堆的性质
                return;
            }
        }
    }
    private void shiftUp(int child){
        int parent = (child - 1) >> 1;
        while(child != 0){
            //if(array[child] < array[parent]){
            if(compare.compare(array[child], array[parent]) < 0){
                swap(child, parent);
                child = parent;
                parent = (child - 1) >> 1;
            }
            else{
                return;
            }
        }
    }
    private void swap(int child, int parent){
        int temp = array[child];
        array[child] = array[parent];
        array[parent] = temp;
    }

    private void grow(){
        int oldCapacity = array.length;
        int newCapacity = oldCapacity + ((oldCapacity < 64) ? (oldCapacity + 2) : oldCapacity >> 1);
        array = Arrays.copyOf(array, newCapacity);
    }
}