PriorityQueue底层你了解多少？（带你彻底掌握优先级队列）

1. 概念

队列是一种先进先出(FIFO)的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列，该中场景下，使用队列显然不合适，比如:在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话。
在这种情况下，我们的数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue)

2. 堆

JDK1.8中的PriorityQueue底层使用了堆的数据结构，而堆实际就是在完全二叉树的基础之上进行了一些元素的调整。

2.1 了解堆

1. 什么是堆？

堆（Heap）是一种特殊的完全二叉树数据结构，它满足以下两个性质之一：

最大堆（Max Heap）：对于任何一个非叶子节点i，i的值总是不小于其子节点的值。
最小堆（Min Heap）：对于任何一个非叶子节点i，i的值总是不大于其子节点的值。

堆通常用于实现优先级队列等数据结构。

2. 堆的性质

完全二叉树：堆是一棵完全二叉树，这意味着树的每一层（除了最后一层）都完全填满，且最后一层的节点都尽可能靠左。
堆序性：最大堆的每个节点的值大于或等于其子节点的值；最小堆的每个节点的值小于或等于其子节点的值。

3. 堆的表示

堆通常使用数组表示。对于一个给定的节点i：

左子节点的索引为2*i + 1
右子节点的索引为2*i + 2
父节点的索引为(i - 1) / 2

`4. 堆的存储方式`

因为是完全二叉树，堆（Heap）通常使用数组（或列表）来存储。这样做的主要原因是数组提供了连续的内存块，可以高效地通过索引访问元素，并且堆的性质允许我们通过数学运算轻松地找到父节点和子节点的位置。

注意:对于非完全二叉树，则不适合使用顺序方式进行存储，因为为了能够还原二叉树，空间中必须要存储空节点，就会导致空间利用率比较低。

2.2 堆的创建

对于集合{ 27,15,19,18,28,34,65,49,25,37}中的数据，如果将其创建成堆呢?

仔细观察上图后发现:根节点的左右子树已经完全满足堆的性质，因此只需将根节点向下调整好即可。

2.2.1 向下过程(以小堆为例):

public void shiftDown(int[] array, int parent) {
        // child先标记parent的左孩子，因为parent可能有左没有右
        int child = 2 * parent + 1;
        int size = array.length;
        while (child < size) {
            // 如果右孩子存在，找到左右孩子中较小的孩子,用child进行标记
            if(child+1 < size && array[child+1] < array[child]){
                child += 1;
            }
            // 如果双亲比其最小的孩子还小，说明该结构已经满足堆的特性了
            if (array[parent] <= array[child]) {
                break;
            }else{
                // 将双亲与较小的孩子交换
                int t = array[parent];
                array[parent] = array[child];
                array[child] = t;
                // parent中大的元素往下移动，可能会造成子树不满足堆的性质，因此需要继续向下调整
                parent = child;
                child = parent * 2 + 1;
            }
        }
    }

大堆为例

那对于普通的序列{1,5,3,8,7,6}，即根节点的左右子树不满足堆的特性，又该如何调整呢?

public static void createHeap(int[] array) {
    // 找倒数第一个非叶子节点，从该节点位置开始往前一直到根节点，遇到一个节点，应用向下调整
    int root = ((array.length-2)>>1);
    for (; root >= 0; root--) {
        shiftDown(array, root);
    }
}

2.3 堆的插入与删除

堆的插入总共需要两个步骤
1.先将元素放入到底层空间中(注意:空间不够时需要扩容)

2.将最后新插入的节点向上调整，直到满足堆的性质

public void shiftUp(int[] array,int child) {
        // 找到child的双亲
        int parent = (child - 1) / 2;
        while (child > 0) {
        // 如果双亲比孩子大，parent满足堆的性质，调整结束
            if (array[parent] > array[child]) {
                break;
            }
            else{
                // 将双亲与孩子节点进行交换
                int t = array[parent];
                array[parent] = array[child];
                array[child] = t;
                // 小的元素向上移动，成为parent之后可能它的父节点仍然不满足要求，因此需要继续向上调增
                child = parent;
                parent = (child - 1) / 2;
            }
        }
    }

堆的删除

注意:堆的删除一定删除的是堆顶元素。具体如下
1.将堆顶元素对堆中最后一个元素交换
2.将堆中有效数据个数减少一个
3. 对堆顶元素进行向下调整

2.4 用堆模拟实现优先级队列

基于前面的代码，我们很简单的就可以基于堆实现一个基本的优先级队列了。

package test;

public class PriorityQueueDemo {

    private int[] array = new int[100];
    private int size = 0;

    public void shiftDown(int[] array, int parent) {
        int child = 2 * parent + 1;
        while (child < size) {
            // 如果右孩子存在，找到左右孩子中较小的孩子，用child进行标记
            if (child + 1 < size && array[child + 1] < array[child]) {
                child++;
            }
            // 如果双亲比其最小的孩子还小，说明该结构已经满足堆的特性了
            if (array[parent] <= array[child]) {
                break;
            } else {
                // 将双亲与较小的孩子交换
                int t = array[parent];
                array[parent] = array[child];
                array[child] = t;
                // parent中大的元素往下移动，可能会造成子树不满足堆的性质，因此需要继续向下调整
                parent = child;
                child = parent * 2 + 1;
            }
        }
    }

    public void shiftUp(int[] array, int child) {
        // 找到child的双亲
        int parent = (child - 1) / 2;
        while (child > 0) {
            // 如果双亲比孩子大，parent满足堆的性质，调整结束
            if (array[parent] <= array[child]) {
                break;
            } else {
                // 将双亲与孩子节点进行交换
                int t = array[parent];
                array[parent] = array[child];
                array[child] = t;
                // 小的元素向上移动，成为parent之后可能它的父节点仍然不满足要求，因此需要继续向上调整
                child = parent;
                parent = (child - 1) / 2;
            }
        }
    }

    public void offer(int e) {
        array[size++] = e;
        shiftUp(array, size - 1);
    }

    public int poll() {
        int oldValue = array[0];
        array[0] = array[--size];
        shiftDown(array, 0);
        return oldValue;
    }

    public int peek() {
        return array[0];
    }

    public static void main(String[] args) {
        PriorityQueueDemo pq = new PriorityQueueDemo();

        // 插入测试
        pq.offer(5);
        pq.offer(3);
        pq.offer(17);
        pq.offer(10);
        pq.offer(84);
        pq.offer(19);
        pq.offer(6);
        pq.offer(22);
        pq.offer(9);

        System.out.println("插入元素后，最小元素是: " + pq.peek());

        // 提取测试
        System.out.println("提取最小元素: " + pq.poll());
        System.out.println("提取最小元素: " + pq.poll());
        System.out.println("提取最小元素: " + pq.poll());

        // 再次插入测试
        pq.offer(2);
        pq.offer(15);

        System.out.println("再次插入元素后，最小元素是: " + pq.peek());

        // 再次提取测试
        System.out.println("提取最小元素: " + pq.poll());
        System.out.println("提取最小元素: " + pq.poll());

        // 打印剩余元素
        System.out.print("优先级队列中剩余的元素: ");
        while (pq.size > 0) {
            System.out.print(pq.poll() + " ");
        }
    }
}

3. Java中的优先级队列PriorityQueue

Java集合框架中提供了PriorityQueue和PriorityBlockingQueue两种类型的优先级队列，PriorityQueue是线程不安全的，PriorityBlockingQueue是线程安全的，这里主要介绍PriorityQueue。

3.1 构造函数

注意：默认情况下，PriorityQueue队列是小堆，如果需要大堆需要用户提供比较器:

// 用户自己定义的比较器：直接实现Comparator接口，然后重写该接口中的compare方法即可
    static class IntCmp implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2-o1;
        }
    }

    public static void main(String[] args) {
        PriorityQueue<Integer> p = new PriorityQueue<>(new IntCmp());
        p.offer(4);
        p.offer(3);
        p.offer(2);
        p.offer(1);
        p.offer(5);
        System.out.println(p.peek());
    }

3.2 插入/删除/获取优先级最高的元素

    static void TestPriorityQueue2(){
        int[] arr = {4,1,9,2,8,0,7,3,6,5};
        // 一般在创建优先级队列对象时，如果知道元素个数，建议就直接将底层容量给好
        // 否则在插入时需要不多的扩容
        // 扩容机制：开辟更大的空间，拷贝元素，这样效率会比较低
        PriorityQueue<Integer> q = new PriorityQueue<>(arr.length);
        for (int e: arr) {
            q.offer(e);
        }
        System.out.println(q.size()); // 打印优先级队列中有效元素个数
        System.out.println(q.peek()); // 获取优先级最高的元素
        // 从优先级队列中删除两个元素之和，再次获取优先级最高的元素
        q.poll();
        q.poll();
        System.out.println(q.size()); // 打印优先级队列中有效元素个数
        System.out.println(q.peek()); // 获取优先级最高的元素
        q.offer(0);
        System.out.println(q.peek()); // 获取优先级最高的元素
        // 将优先级队列中的有效元素删除掉，检测其是否为空
        q.clear();
        if(q.isEmpty()){
            System.out.println("优先级队列已经为空!!!");
        }
        else{
            System.out.println("优先级队列不为空");
        }
    }

3.3 扩容机制

JDK1.8源码中对于PQ的扩容机制：

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

private void grow(int minCapacity) {
        int oldCapacity = queue.length;
        // Double size if small; else grow by 50%
        int newCapacity = oldCapacity + ((oldCapacity < 64) ?
                                         (oldCapacity + 2) :
                                         (oldCapacity >> 1));
        // overflow-conscious code
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        queue = Arrays.copyOf(queue, newCapacity);
    }

private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }

优先级队列的扩容说明：