【数据结构】优先级队列（堆）

一 前言

优先级队列的概念：优先级队列类似于普通队列，但元素的出队顺序是根据优先级决定的，优先级高的元素先出队，优先级低的元素后出队。

堆的概念：

1.堆是完全二叉树

2.堆的节点具有堆序性：大根堆的父节点值大于等于子节点，小根堆的父节点的值小于等于子节点

JDK1.8中PriorityQueue底层使用了堆这种数据结构，而堆是在二叉树的基础上进行的调整。

二 堆的实现

😶‍🌫️1.堆的创建（大根堆为例）

public class TestHeap {
    private int[] elem;
    private int usedSize;//数组长度10

    public TestHeap(){
        this.elem = new int[10];
    }

    public void initHeap(int[] array){
        for (int i = 0; i < array.length; i++) {
            elem[i] = array[i];
            usedSize++;
        }
    }

    public void createHeap(){
        //partent求的是p节点下标
        for (int partent = (usedSize-1-1)/2; partent >= 0 ; partent--) {
            shiftDown(partent, usedSize);
        }
    }

    private void shiftDown(int partent, int usedSize){
        int child = (2*partent)+1;//左孩子下标
        while(child < usedSize){
            //elem[child] > elem[partent]左右孩子比较
            //child+1 < usedSize防止右孩子不存在报错
            if(child+1 < usedSize && elem[child] < elem[child+1]){
                child++;
            }
            //child一定是左右孩子最大值的下标
            if(elem[child] > elem[partent]){
                swap(child,partent);
                partent = child;
                child = 2*partent+1;
            }else{
                //已经是大根堆了
                break;
            }
        }
    }

    private void swap(int i, int j){
        int tmp = elem[i];
        elem[i] = elem[j];
        elem[j] = tmp;
    }
}

😶‍🌫️2.建堆的时间复杂度

 

😶‍🌫️3.堆的插入和删除

堆的插入思路：

调试：

代码：

/*堆的插入*/
    public void offer(int val){
        if(isFull()){
            this.elem = Arrays.copyOf(elem, 2*elem.length);
        }
        this.elem[usedSize] = val;//usedSize =10， 在下标10的位置插入90
        //向上调整
        shiftUp(usedSize);
        usedSize++;
    }

    private void shiftUp(int child){
        int partent =(child - 1)/2;
        while(child > 0){
            if(elem[child] > elem[partent]){
                swap(child, partent);
                child = partent;
                partent = (child - 1)/2;
            }else{
                break;
            }
        }
    }

    public boolean isFull(){
        return usedSize == elem.length;
    }

堆的删除思路：

调试：

代码：

   /*堆的删除*/
    public int poll(){
        int tmp = elem[0];
        swap(0, usedSize-1);
        usedSize--;
        shiftDown(0,usedSize);
        return tmp;
    }

练习：

三 PriorityQueue接口

😶‍🌫️1.PriorityQueue特性

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

2.PriorityQueue中必须放置可比较大小的元素，否则会抛出ClassCstException异常

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

4.内部可以自动扩容

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

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

7.PriorityQueue默认情况下是小根堆

😶‍🌫️2.PriorityQueue常用接口

❤️优先级队列的构造

    public static void main(String[] args) {
        //1.创建一个空的优先级队列，默认容量11
        PriorityQueue<Integer> q1 = new PriorityQueue<>();
        
        //2.创建一个空的优先级队列，底层容量为100
        PriorityQueue<Integer> q2 = new PriorityQueue<>(100);
        
        //3.用ArrayList对象来构造一个优先级队列的对象
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        PriorityQueue<Integer> q3 = new PriorityQueue<>(list);
        System.out.println(q3.size());
        System.out.println(q3.poll());
    }

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

源代码分析：

 //比较器实现大根堆
    class IntCmp implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2.compareTo(o1);
        }
    }

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

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

注意：在创建优先级队列对象时，如果知道元素个数就之间将底层容量给好，否则在插入时需要不多的扩容，这样的话会开辟更大的空间，效率比较低。

四 练习

❤️top-k问题：最大或者最小的前k个数据

1.最大k个数：设计一个算法，找出数组中最大的k个数。以任意顺序返回这k个数均可。

  /*前k个最大的数据*/
    public static int[] maxLestK(int[] array, int k){
        int[] ret = new int[k];
        if(array == null || k <= 0){
            return ret;
        }

        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
        //建小根堆
        for (int i = 0; i < k; i++) {
            priorityQueue.offer(array[i]);
        }

        for (int i = k; i < array.length; i++) {
            //堆顶元素赋值给top
            int top = priorityQueue.peek();
            if(array[i] > top){//如果i下标的元素大于堆顶元素
                priorityQueue.poll();//把堆顶元素移除
                priorityQueue.offer(array[i]);//i下标元素进堆并按照小根堆模式重新比较
            }
        }
        //打印出前k个元素：堆中元素赋给ret数组
        for (int i = 0; i < k; i++) {
            ret[i] = priorityQueue.poll();
        }
        return ret;
    }

     public static void main(String[] args) {
        int[] array = {10,5,3,9,2};
        int[] ret2 = TestHeap.maxLestK(array, 3);
        System.out.println(Arrays.toString(ret2));
    }
   

2.最小k个数：设计一个算法，找出数组中最小的k个数。以任意顺序返回这k个数均可。

---

❤️堆排序：从小到大对原来的数据进行排序

 /*堆排序*/
    public void heapSort(){
        int end = usedSize-1;
        while(end > 0){
            swap(0, end);
            shiftDown(0, end);
            end--;
        }
    }

---