Java数据结构 | PriorityQueue详解

目录

一 、PriorityQueue

二、PriorityQueue常用方法介绍

三、 PriorityQueue源码剖析

四:应用:Top-K问题


一 、PriorityQueue

  • 常用接口介绍

上文中我们介绍了优先级队列的模拟实现, Java集合框架中提供了PriorityQueuePriorityBlockingQueue两种类型的优先级队列,此处我们主要刨析和介绍PriorityQueue

4e7c1a84bcf28502efc4d7df77f2290e.png

关于PriorityQueue的使用要注意:

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

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

ClassCastException*异常**

  1. 不能插入null对象,否则会抛出NullPointerException**

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

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

  4. PriorityQueue底层使用了堆数据结构, (注意:此处大家可以不用管什么是堆,后文中有介绍)

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

二、PriorityQueue常用方法介绍

  • 构造方法

常用的三个构造方法如下:

1d28a212dc43c529e770b656a1095cec.png

public class TestDemo2 {
    public static void main(String args[]){
//      创建一个空的优先级队列,底层容量默认为11
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
        priorityQueue.offer(10);
        priorityQueue.offer(20);
        priorityQueue.offer(12);
        priorityQueue.offer(23);
        System.out.println(priorityQueue.poll());
        System.out.println(priorityQueue.poll());
        System.out.println(priorityQueue.poll());
        System.out.println(priorityQueue.poll());
//        创建一个指定初始容量的优先级队列,容量指定位100
        PriorityQueue<Integer> priorityQueue1 = new PriorityQueue<>(100);
//        使用ArrayList对象来创建一个优先级队列的对象(只要实现Collection接口的,都可以存入)
        List<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(32);
        PriorityQueue<Integer> priorityQueue2 = new PriorityQueue<>(list);
        System.out.println(priorityQueue2.poll());
        System.out.println(priorityQueue2.poll());
    }
}

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

e049e3bdcf9b2f56d39dad1b8b43ab9c.png

三、 PriorityQueue源码剖析

  • 使用Student对象来创建一个优先级队列的对象

当我们在priorityQueue中存放一个Student 对象时, 可以正常放入且不发生报错。

但是当我们存放两个Studnet对象时,程序报错,出现类型不兼容异常。

public class TestDemo2 {
//    注意:默认情况下,PriorityQueue队列是小堆,如果需要大堆需要用户提供比较器
    public static void main(String[] args) {
        PriorityQueue<Student> priorityQueue = new PriorityQueue<>();
        priorityQueue.offer(new Student(10));
        priorityQueue.offer(new Student(5));
    }
 }

0fd6bc3220869115d5a5f642df12c894.png

前边学习抽象类和常用接口时,我们了解到Java中对于引用数据类型的比较或者排序,一般都要用到使用Comparable接口中的compareTo() 方法

此时我们可以实现Comparable接口,并且重写 compare()方法。

class Student implements Comparable<Student>{
    public int age;
    public Student(int age) {
        this.age = age;
    }
    @Override
    public int compareTo(Student o) {
        return this.age - o.age;
    }
}
public class TestDemo2 {
//    注意:默认情况下,PriorityQueue队列是小堆,如果需要大堆需要用户提供比较器
    public static void main(String[] args) {
        PriorityQueue<Student> priorityQueue = new PriorityQueue<>();
        priorityQueue.offer(new Student(10));
        priorityQueue.offer(new Student(5));
    }
}

经过调试我们可以发现,此时优先级队列中的两个元素已经按照小根堆的方式调整好了。

0653d9fc42d8553548acd28d50532eff.png

那么PriorityQueue是怎么对其中的引用数据类型进行调整的呢?

2d3e2a7b2e1e046a782af4fedd17603b.png

使用this引用指向了下边的方法,并传递参数。

0f5d46ef235c34074818ef17e04e6860.png

当queue数组初始化完毕时, 需要向数组中存放元素,即进行 priorityQueue.offer(new Student(10));

a357ae03bff5a5a7d9daf181f1827bde.png

存放第二个元素时,i = 1 , size = 2 ,则需要执行 siftUp(1 , e) ,对 元素进行向上调整为小根堆 。

41bcef9cd1147433157d48a662ee4046.png

向下调整的过程中,使用了我们所重写的compareTo()方法,然后判断e,key对应的age的值,进行交换,如果此处不需要交换,则直接将key放入queue[1] 中即可 , 此时,小根堆调整完成

fa67bcbb6cda9b6154bf8058f573602b.png

如果想要调整为大根堆的话,只需要修改Student类中的compareTo()方法即可

class Student implements Comparable<Student>{
    public int age;
    public Student(int age) {
        this.age = age;
    }
    @Override
    public int compareTo(Student o) {
        return o.age - this.age;
    }
}

cdb19d71f069688b738c505600307695.png

那么Integer类型的参数该如何修改为大根堆 呢? ,Integer类型已经重写了compareTo方法,但是已经写死了,默认为小根堆的实现方式,无法修改源码,此时,我们就应该 构造Comparator 比较器来实现。

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

❗当传入比较器时,PriorityQueue会按照 比较器的方式进行 比较,与实现Comparable 接口的方法类似,此处不再赘述,元素进而被调整为大根堆。

d87918ed651e195c24dd8e6cfffd5168.png

91906c6bcaf27804ca71635b89eeda96.png

✅另一种写法 :

public class TestPriorityQueue {
     public static void main(String[] args) { 
     //匿名内部类,这里有一个类,实现了Comparator 这个接口,并重写了compare这个方法
           PriorityQueue<Integer> p = new PriorityQueue<>(new Comparator<Integer>() {
               @Override
               public int compare(Integer o1, Integer o2) { 
                   return o2 - o1;
               }
           });
    }
}

🔻PriorityQueue的扩容机制:

c84109602dae041fefbc39e611c8a472.png

优先级队列的扩容说明:

  • 如果容量小于64时,是按照约oldCapacity的2倍方式扩容的(2*OldCapacity+2)

  • 如果容量大于等于64,是按照oldCapacity的1.5倍方式扩容的

  • 如果容量超过MAX_ARRAY_SIZE,按照MAX_ARRAY_SIZE来进行扩容

四:应用-Top-K问题

对于Top-K问题,能想到的最简单直接的方式就是排序,但是:如果数据量非常大,排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决,基本思路如下:

  1. 用数据集合中前K个元素来建堆

前k个最大的元素,则建小堆

前k个最小的元素,则建大堆

  1. 用剩余的**N-K个元素依次与堆顶元素来比较,不满足则替换堆顶元素**

将剩余N-K个元素依次与堆顶元素比完之后,堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

2db7cb5bb7f400e0d12608cd8a9d6d4e.png

在不使用Arrays.sorrt 的情况下,使用优先级队列,(忽略时间复杂度)可以这样写:

1 . 先将数组全部放入堆中,堆会自动调整为小根堆。

2 . 每次将堆顶元素弹出,堆调整之后,再继续弹出共k 个堆顶。

class Solution{
    public int[] smallestK(int[] arr,int k){
        PriorityQueue<Integer> pr = new PriorityQueue<>();
        for(int i = 0 ;i < arr.length ;i++){
            pr.offer(arr[i]);
        }
        int[] tmp = new int[k];
        for(int i = 0 ;i < k ;i ++){
            tmp[i] = pr.poll();
        }
        return tmp;
    }
}

此时的时间复杂度为 O(n+klog(n)),那么如何调整可以使时间复杂度进一步优化呢?

1.先将这组数据中的前K个数据建立为大根堆

2. 从K+1个元素开始,每次和堆顶元素进行比较,如果i下标的元素小于堆顶元素,则进行出堆。

区别:1 . 没有整体建堆(大小为K的堆) 2. 遍历剩下n-k 个元素,每个元素与堆顶元素比较。

class Solution {
     public int[] smallestK(int[] arr, int k) {
         int[] vec = new int[k];
         if (k == 0) {
             return vec;
         }
         //传入比较器,按照大根堆调整
         PriorityQueue<Integer> queue = new PriorityQueue<Integer>(new Comparator<Integer>() {
            public int compare(Integer num1, Integer num2) {
                 return num2 - num1;
             }
         });
         //存入K个 元素
         for (int i = 0; i < k; ++i) {
             queue.offer(arr[i]);
         }
         //比较堆顶元素与剩余n - k个元素的值的大小
         //如果堆顶元素较大,则弹出堆顶,重新调整,元素入堆
         for (int i = k; i < arr.length; ++i) {
             if (queue.peek() > arr[i]) {
                 queue.poll();
                 queue.offer(arr[i]);
             }
         }
         //将堆中元素存入数组中
         for (int i = 0; i < k; ++i) {
             vec[i] = queue.poll();
         }
         return vec;
     }
 }

此时已经可以求出前K个最小的元素,且时间复杂度为Nlog(K)那么第K小的元素如何去求呢?步骤基本是相似的

1.先将这组数据中的前K个数据建立为大根堆

2. 从K+1个元素开始,每次和堆顶元素进行比较,如果i下标的元素小于堆顶元素,则进行出堆。

3 . 比较完成后直接弹出堆顶元素,即为第K小的元素。

    到这里优先级队列部分的内容就结束了,欢迎点赞评论收藏。。💖

ced485cbb11e458d81a746890b32cf3f.gif

 

  • 52
    点赞
  • 49
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 36
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 36
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

署前街的少年

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值