优先级队列：PriorityQueue常用接口+构造+方法+源码分析+OJ练习

---

PriorityQueue常用接口

---

一、概念

一.PriorityQueue 的特性

• 1.Java集合框架中提供了 **PriorityQueue **和 **PriorityBlockingQueue **两种类型的优先级队列
• 2.PriorityQueue是线程不安全的，PriorityBlockingQueue是线程安全的

PriorityQueue底层由堆实现，堆由数组构造

import java.util.PriorityQueue;   
public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue1 = new PriorityQueue<>();
        //直接实例化对象
        Queue<Integer> priorityQueue2 = new PriorityQueue<>();//默认是小根堆
        //用接口来调用
    }

• 3.使用时必须导入PriorityQueue所在的包
• 4.PriorityQueue中放置的元素，必须要能够比较大小，否则会抛出类型转换ClassCastException异常

        priorityQueue2.offer(new Student(12));
        priorityQueue2.offer(new Student(32));//ClassCastException,没有指定比较的元素，对象本身无法比较

1. PriorityQueue的offer方法，用的是向上调整，siftUp里面，用到了Comparator和Comparable方法
2. 要比较大小就要先实现Comparator和Comparable

• 5.不能插入null对象，否则会抛出空指针异常NullPointerException
• 6.内部会自动扩容
• 7.插入和删除元素的时间复杂度为 O ( log₂N )
• 8.PriorityQueue底层使用了堆的数据结构，默认是小根堆

二.PriorityQueue常用接口介绍

1.优先级队列的构造

• PriorityQueue() 不带参数的构造方法

创建一个空的优先级队列

调用无参构造器，初始容量默认为11，默认没有构造器

• PriorityQueue(int initialCapacity)

默认没有构造器

创建一个初始容量为initialCapacity的优先级队列，initialCapacity不能小于1，否则会抛IllegalArgumentException异常

• PriorityQueue(Collection<?extends E> c)

用一个集合来创建优先级队列

• PriorityQueue队列是小堆，如果需要大堆需要提供比较器

// 用户自己定义的比较器：直接实现Comparator接口，然后重写该接口中的compare方法即可

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

函数名	功能介绍
boolean offer(E e)	插入元素e，插入成功返回true，如果e对象为空，抛出NullPointerException异常时间复杂度O ( log2N )
E peek()	获取优先级最高的元素，如果优先级队列为空，返回null
E poll()	移除优先级最高的元素并返回，如果优先级队列为空，返回null
int size()	获取有效元素的个数
void clear()	清空
boolean isEmpty()	检测优先级队列是否为空

3.PriorityQueue的扩容方式：

1.如果容量小于64时，是按照oldCapacity的2倍方式扩容

2.如果容量大于等于64，是按照oldCapacity的1.5倍方式扩容的

3.如果容量超过MAX_ARRAY_SIZE，按照MAX_ARRAY_SIZE来进行扩容

二.OJ练习：

1.最小的K个数

方法一：

建立小根堆，取k次堆顶元素

    //前K个最小的值
    // 方法1
    //N*logN+ K* logN
    public static int[] smallestK1(int[] arr, int k) {
        int[] ret = new int[k];
        if (arr == null || k == 0) {
            return ret;
        }
        //向上调整的时间复杂度 N*logN
        Queue<Integer> minHeap = new PriorityQueue<>(arr.length);
        for (int x : arr) {
            minHeap.offer(x);
        }
        //弹出向下调整  K* logN
        for (int i = 0; i < k; i++) {
            ret[i] = minHeap.poll();
        }
        return ret;
    }

方法二：

• 要找K个最小的元素，大根堆的堆顶是堆中最大的，只有比堆顶元素小，才能符合要求进堆，并删除堆顶元素

1.求前K个最小的元素

2.只建K个元素组成的堆，建的是大根堆

3.遍历剩下的元素，如果比堆顶元素大，就不进堆

4.比堆顶元素小，堆顶元素删除，将元素进堆，再次维护大根堆

class Solution {
    public int[] smallestK(int[] arr, int k) {
 int[] ret = new int[k];
        if (arr == null || k == 0) {
            return ret;
        }
        Queue<Integer> maxHeap = new PriorityQueue<>(new Comparator<Integer>() {
            public int compare(Integer num1, Integer num2) {
                return num2 - num1;
            }
        });

        for (int i = 0; i < k; i++) {
            maxHeap.offer(arr[i]);
        }
        for (int i = k; i < arr.length; i++) {
            int val = maxHeap.peek();
            if (arr[i]<val){
                maxHeap.poll();
                maxHeap.offer(arr[i]);
            }
        }
        for (int i = 0; i < k; i++) {
            ret[i] = maxHeap.poll();
        }
        return ret;
    }
}

2.TOP-K

TOP-K问题：即求数据集合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大

• 要找K个最大的元素，小根堆的堆顶是堆中最小的，只有比堆顶元素大，才能符合要求进堆，并删除堆顶元素

1.求前K个最大的元素

2.建K个元素组成的小根堆

3.遍历剩下的元素，如果比堆顶元素小，就不进堆，比堆顶元素大，进堆比较

4.比堆顶元素大，堆顶元素删除，将元素进堆，再次维护小根堆

   /**
     * 前K个最大的元素
     *时间复杂度 N*logK
     * @param arr
     * @param k
     * @return
     */
    public static int[] maxK(int[] arr, int k) {
        int[] ret = new int[k];
        if (arr == null || k == 0) {
            return ret;
        }
        Queue<Integer> minHeap = new PriorityQueue<>(k);//见一个大小为k的堆

        //1.遍历数组的前K个元素，放入堆中
        //时间复杂度：k*logK
        for (int i = 0; i < k; i++) {
            minHeap.offer(arr[i]);
        }
        //2.遍历剩下的元素，和堆顶元素进行比较
        //堆顶元素小，出堆
        //时间复杂度：(N-K)logK
        for (int i = k; i < arr.length; i++) {
            int val = minHeap.peek();
            if (arr[i] > val) {
                minHeap.poll();
                minHeap.offer(arr[i]);
            }
        }
        for (int i = 0; i < k; i++) {
            ret[i] = minHeap.poll();
        }
        return ret;
    }

找到第K大的元素

就是小根堆的堆顶元素

点击移步博客主页，欢迎光临~