PriorityQueue及其构造

常用接口：

• PriorityQueue是线程不安全的
• PriorityBlockingQueue是线程安全的

这里只说PriorityQueue。
PriorityQueue不能插入null对象，否则会抛出NullPointerException
PriorityQueue中放置的元素必须要能够比较大小，不能插入无法比较大小的对象，否则会抛出ClassCastException异常

public static void main(String[] args) {
        PriorityQueue<int[]> priorityQueue = new PriorityQueue<>();
        int[] arr1 = {2,3};
        int[] arr2 = {1,3};
        priorityQueue.offer(arr1);
        priorityQueue.offer(arr2);
        int[] arr3 = priorityQueue.peek();
        System.out.println(Arrays.toString(arr3));
    }

PriorityQueue底层使用了堆的数据结构
堆：一颗 顺序存储 的完全二叉树 (数组中 存储的是 这颗二叉树的 层序遍历)

•  大堆（大根堆）：根节点的值 > 左右孩子节点的值
  

•  小堆（小根堆）：根节点的值 < 左右孩子节点的值
  

PriorityQueue : 底层是小根堆

public static void main1(String[] args) {
      
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
        priorityQueue.offer(10);
        priorityQueue.offer(2);
        priorityQueue.offer(1);
        priorityQueue.offer(8);

        System.out.println(priorityQueue.peek());//1 数越小，优先级越高
        System.out.println(priorityQueue.poll());//1
        System.out.println(priorityQueue.poll());//2

    }

创建一个空的优先级队列，默认容量是11
优先级队列的扩容说明：

• 如果容量小于64时，是按照oldCapacity*2 + 2的方式扩容的
• 如果容量大于等于64，是按照oldCapacity*1.5的方式扩容的

优先级队列的构造

public class TestHeap{
	public int[] elem;
    public int usedSize;

    public TestHeap() {
        this.elem = new int[10];
    }
// 堆向下调整 为 小根堆
    public void adjusDown2(int root, int len) {
        int p = root;
        int c = 2*p + 1;
        while (c < len) {
            if (c+1 < len && this.elem[c] > this.elem[c+1]) {
                c++;
            }
            if (this.elem[p] > this.elem[c]){
                int t = this.elem[p];
                this.elem[p] = this.elem[c];
                this.elem[c] = t;
                p = c;
                c = 2*p + 1;
            }else {
                break;
            }
        }
    }

    //创建小根堆
    public void createHeap2(int[] array) {
        for (int i = 0; i < array.length; i++) {
            this.elem[i] = array[i];
            this.usedSize++;
        }
        System.out.println(Arrays.toString(this.elem));
        for (int i = (this.usedSize-1-1)/2; i >= 0; i--) {
            adjusDown2(i,this.usedSize);
        }
    }
}