数据结构---优先级队列

概念

队列是一种先进先出 的数据结构 ，但有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列，在这种情况下，我们的数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象 。

PriorityQueue的使用

1. 使用时必须导入 PriorityQueue 所在的包

2. PriorityQueue 中放置的 元素必须要能够比较大小，不能插入无法比较大小的对象，否则会抛出

ClassCastException 异常

3. 不能 插入 null 对象，否则会抛出 NullPointerException

4. 没有容量限制，可以插入任意多个元素，其内部可以自动扩容

5. 插入和删除元素的时间复杂度为O（logN）

6. PriorityQueue 底层使用了堆数据结构

7. PriorityQueue 默认情况下是小堆 --- 每次获取到的元素都是最小的元素

创建优先级序列

 

 内部方法

 模拟实现

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);
    }
}
 

参考： Java中优先级队列的基本知识_流年、烟雨-优快云博客