【数据结构】源码角度剖析PriorityQueue

目录

认识 Queue

认识 PriorityQueue

PriorityQueue为什么要用二叉堆？

PriorityQueue构造方法源码分析

PriorityQueue 的属性

构造方法

JDK1.8传入不可比较的对象

JDK17传入不可比较的对象

传入带有Collection接口的对象 

instanceof 关键字

Offer方法分析 

JDK8Offer分析（传入可比较对象）

JDK17Offer分析（传入可比较对象）

JDK17Offer(手动传入比较器)

PriorityQueue 扩容机制

模拟堆操作

认识 Queue

Queue 是单端队列，只能从一端插入元素，另一端删除元素，实现上一般遵循 先进先出 规则。

下面我们看看常见的方法：

Queue 扩展了 Collection 的接口，根据 因为容量问题而导致操作失败后处理方式的不同 可以分为两类方法: 一种在操作失败后会抛出异常，另一种则会返回特殊值。

Queue接口抛出异常返回特殊值
插入队尾add(E e)offer(E e)
删除队首remove()poll()
查询队首元素element()peek()

认识 PriorityQueue

PriorityQueue是在 JDK1.5 中被引入的, 其与 Queue 的区别在于元素出队顺序是与优先级相关的，即总是优先级最高的元素先出队。

这里列举其相关的一些要点：

  • PriorityQueue 利用了二叉堆的数据结构来实现的，底层使用可变长的数组来存储数据
  • PriorityQueue 通过堆元素的上浮和下沉，实现了在 O(logn) 的时间复杂度内插入元素和删除堆顶元素。
  • PriorityQueue 是非线程安全的，且不支持存储 NULL（否则会抛出NullPointerException） 和 non-comparable（否则会抛出 ClassCastException异常） 的对象。
  • PriorityQueue 默认是小堆，但可以接收一个 Comparator 作为构造参数，从而来自定义元素优先级的先后。

 

PriorityQueue为什么要用二叉堆？

PriorityQueue 选择使用二叉堆（Binary Heap）作为底层数据结构的原因主要是为了维护堆的性质，并保证一些基本操作的高效性能。二叉堆是一种特殊的完全二叉树，有两种类型：最小堆和最大堆。

以下是使用二叉堆的一些优势和原因：

  1. 高效的插入和删除操作： 二叉堆保持了堆的性质，使得插入和删除元素的操作非常高效。在最小堆中，堆顶元素是最小的，删除堆顶元素（poll操作）只需要常数时间，而插入元素也可以在对数时间内完成。

  2. 空间效率： 二叉堆可以使用数组实现，这样可以更有效地利用内存。相比于其他数据结构，它在实现上不需要额外的指针，而且数组的顺序存储有助于提高缓存命中率。

  3. 快速找到最小/最大元素： 在最小堆中，最小元素总是位于堆顶。在最大堆中，最大元素总是位于堆顶。这样，我们可以在常数时间内找到最小或最大元素。

  4. 适用于动态数据： 二叉堆对于动态数据集的管理非常有效，因为在插入和删除元素时，它能够在对数时间内维护堆的性质。

虽然二叉堆可能不是最适合所有情况的数据结构，但在某些场景下，特别是对于优先队列的实现，它提供了一种简单而高效的选择。注意，Java 中的 PriorityQueue 默认实现是最小堆，但可以通过提供自定义的比较器来实现最大堆。

PriorityQueue构造方法源码分析

就第三点：PriorityQueue 不支持存储 NULL（否则会抛出NullPointerException） 和 non-comparable（否则会抛出 ff异常） 的对象。

我们来看看源码：

PriorityQueue 的属性

下面为 PriorityQueue 的属性：（如想了解源码中的序列化和modCount相关知识，可移步博主另一篇博客ArrayList（源码分析））

    // 默认初始化大小private static final int DEFAULT_INITIAL_CAPACITY = 11;// 用数组实现的二叉堆，下面的英文注释确认了我们前面的说法。/*** Priority queue represented as a balanced binary heap: the two* children of queue[n] are queue[2*n+1] and queue[2*(n+1)].  The* priority queue is ordered by comparator, or by the elements'* natural ordering, if comparator is null: For each node n in the* heap and each descendant d of n, n <= d.  The element with the* lowest value is in queue[0], assuming the queue is nonempty.*/private transient Object[] queue ;// 队列的元素数量private int size = 0;// 比较器private final Comparator<? super E> comparator;// 修改版本private transient int modCount = 0;

构造方法

/*** 默认构造方法，使用默认的初始大小来构造一个优先队列，比较器comparator为空，这里要求入队的元素必须实现Comparator接口*/public PriorityQueue() {this(DEFAULT_INITIAL_CAPACITY, null);}/*** 使用指定的初始大小来构造一个优先队列，比较器comparator为空，这里要求入队的元素必须实现Comparator接口*/public PriorityQueue( int initialCapacity) {this(initialCapacity, null);}/*** 使用指定的初始大小和比较器来构造一个优先队列*/public PriorityQueue( int initialCapacity,Comparator<? super E> comparator) {// Note: This restriction of at least one is not actually needed,// but continues for 1.5 compatibility// 初始大小不允许小于1if (initialCapacity < 1)throw new IllegalArgumentException();// 使用指定初始大小创建数组this.queue = new Object[initialCapacity];// 初始化比较器this.comparator = comparator;}/*** 构造一个指定Collection集合参数的优先队列*/public PriorityQueue(Collection<? extends E> c) {// 从集合c中初始化数据到队列initFromCollection(c);// 如果集合c是包含比较器Comparator的(SortedSet/PriorityQueue)，则使用集合c的比较器来初始化队列的Comparatorif (c instanceof SortedSet)comparator = (Comparator<? super E>)((SortedSet<? extends E>)c).comparator();else if (c instanceof PriorityQueue)comparator = (Comparator<? super E>)((PriorityQueue<? extends E>)c).comparator();//  如果集合c没有包含比较器，则默认比较器Comparator为空else {comparator = null;// 调用heapify方法重新将数据调整为一个二叉堆heapify();}}/*** 构造一个指定PriorityQueue参数的优先队列*/public PriorityQueue(PriorityQueue<? extends E> c) {comparator = (Comparator<? super E>)c.comparator();initFromCollection(c);}/*** 构造一个指定SortedSet参数的优先队列*/public PriorityQueue(SortedSet<? extends E> c) {comparator = (Comparator<? super E>)c.comparator();initFromCollection(c);}/*** 从集合中初始化数据到队列*/private void initFromCollection(Collection<? extends E> c) {// 将集合Collection转换为数组aObject[] a = c.toArray();// If c.toArray incorrectly doesn't return Object[], copy it.// 如果转换后的数组a类型不是Object数组，则转换为Object数组if (a.getClass() != Object[].class)a = Arrays. copyOf(a, a.length, Object[]. class);// 将数组a赋值给队列的底层数组queuequeue = a;// 将队列的元素个数设置为数组a的长度size = a.length ;}

JDK1.8传入不可比较的对象

接下来我们先来看一组场景：在PriorityQueue中插入未提供排序方法的对象，以此来展示构造方法

JDK1.8：

：第一次放入一个不可比较的对象不会报错，第二次时候才报错，原因下面讲解offer源码时候会解释。

JDK17传入不可比较的对象

而JDK17（第一次放入一个不可比较的对象就立即报错）：

如果将Student实现Comparable接口就不会报错（以下均为JDK17实现）：

import java.util.PriorityQueue;
class Student implements Comparable<Student>{public int age;public Student(int age) {this.age = age;}@Overridepublic int compareTo(Student o) {return this.age - o.age;}
}
public class Main {public static void main(String[] args) {PriorityQueue<Student> queue = new PriorityQueue<>();queue.offer(new Student(11));queue.offer(new Student(7));System.out.println(1);
//        queue.add(new Student(12));}
}

运行结果：排序成功

传入带有Collection接口的对象 

 

代码实现：

分析：ArrayList实现了Collection接口，所以可以直接进行排序（PriorityQueue 默认小根堆）。

instanceof 关键字

instance of 是 Java 中的一个关键字，用于检查对象是否是某个类的实例，或者是否实现了某个接口。它的语法是：

object instanceof Class

其中，object 是一个对象，而 Class 是一个类名或接口名。instanceof 的结果是一个布尔值，如果 object 是 Class 的实例或者实现了 Class 接口，则结果为 true；否则，结果为 false。

例如，考虑以下代码：

List<String> myList = new ArrayList<>();
if (myList instanceof ArrayList) {System.out.println("myList is an instance of ArrayList");
} 
if (myList instanceof List) {System.out.println("myList is an instance of List");
}

在这个例子中，myList是 ArrayList 类型的实例，所以第一个条件为 true，而第二个条件也为 true，因为 ArrayList 是 List 接口的实现。因此，会输出两行信息。 

Offer方法分析 

分析以上场景所用到的构造方法：

第一次offer：new Student（11）；

当未给构造方法传入参数的时候，源码中会调用自身带有两个参数的构造方法，并设置数组的初始容量为11。

 带有两个参数的构造方法如下：

由于之前我们并未对构造方法传入比较器，所以这里的比较器为 null。 容量为初始容量：11。

讲到这里：代码中，PriorityQueue<Student> queue = new PriorityQueue<>();所作的任务已经完成。

JDK8Offer分析（传入可比较对象）

下面我们来看看offer源码的实现：

（JDK8中的offer），这也是为什么我们前面第一次放入未实现Comparable接口的Student对象未报错：

JDK17Offer分析（传入可比较对象）

JDK17源码：

无论是第几次放入元素，都会先进行类型转换（未传入比较器的情况下，如果传入对象未实现Compara接口，就会抛出异常——ClassCastException）。

下面我们重点关注 siftUpComparable 方法的内部实现：

    private static <T> void siftUpComparable(int k, T x, Object[] es) {Comparable<? super T> key = (Comparable<? super T>) x;while (k > 0) {int parent = (k - 1) >>> 1;Object e = es[parent];if (key.compareTo((T) e) >= 0)break;es[k] = e;k = parent;}es[k] = key;}

 图解分析：

可以看出JDK17，对类型检查更为严格。

第二次Offer操作：new Student(7)

以下为siftUpComparable的具体实现： 

看到这里，我们知道，就可以通过我们自定义的compareTo方法来实现排序的顺序。

但是，如果我们传入的是整数呢？我们知道在进行offer操作的时候，整数会自动装箱成为Integer类型，但是我们不可能修改Integer的源码吧？

public class Main {public static void main(String[] args) {PriorityQueue<Integer> queue = new PriorityQueue<>();queue.offer(10);queue.offer(12);}
}

JDK17Offer(手动传入比较器)

因此这时候比较器就派上用场了：

class IntCom implements Comparator<Integer> {@Overridepublic int compare(Integer o1, Integer o2) {return o1.compareTo(o2);}
}
public class Main {public static void main(String[] args) {PriorityQueue<Integer> queue = new PriorityQueue<>(new IntCom());queue.offer(19);queue.offer(12);}
}

接下来我们再来看看关于比较器的源码部分：

offer方法如下：

由于这里的siftUpUsingComparator部分与上面的传入带Comparable接口的对象差不多，这里就不作过多介绍。 

PriorityQueue 扩容机制

模拟堆操作

import java.util.Arrays;public class Heap_imitate {public int[] elem;public int usedSize;//有效的数据个数public static final int DEFAULT_SIZE = 10;public Heap_imitate() {elem = new int[DEFAULT_SIZE];}public void initElem(int[] array) {for (int i = 0; i < array.length; i++) {elem[i] = array[i];usedSize++;}}/*** 时间复杂度：O(n)*/public void createHeap() {for (int parent = (usedSize-1-1)/2; parent >= 0 ; parent--) {//统一的调整方案shiftDown(parent,usedSize);}}/**** @param parent 每棵子树的根节点* @param len  每棵子树调整的结束位置 不能>len*             时间复杂度：O(log n)*/private void shiftDown(int parent,int len) {int child = 2*parent+1;//1. 必须保证有左孩子while (child < len) {//child+1 < len && 保证有右孩子if(child+1 < len && elem[child] < elem[child+1]) {child++;}//child下标 一定是左右孩子 最大值的下标/* if(elem[child] < elem[child+1] && child+1 < len ) {child++;}*/if(elem[child] > elem[parent]) {int tmp = elem[child];elem[child] = elem[parent];elem[parent] = tmp;parent = child;child = 2*parent+1;}else {break;}}}public void offer(int val) {if(isFull()) {//扩容elem = Arrays.copyOf(this.elem,2*this.elem.length);}this.elem[usedSize] = val;usedSize++;//想办法让他再次变成大根堆shiftUp(usedSize-1);}private void shiftUp(int child) {int parent = (child-1) / 2;while (child > 0) {//parent >= 0if (elem[child] > elem[parent]) {int tmp = elem[child];elem[child] = elem[parent];elem[parent] = tmp;child = parent;parent = (child-1)/2;}else {break;}}}public boolean isFull() {return usedSize == elem.length;}public int pop() {if(isEmpty()) {return -1;}int tmp = elem[0];elem[0] = elem[usedSize-1];elem[usedSize-1] = tmp;usedSize--;//保证他仍然是一棵大根堆shiftDown(0,usedSize);return tmp;}public boolean isEmpty() {return usedSize == 0;}public int peek() {if(isEmpty()) {return -1;}return elem[0];}/*** 时间复杂度：*  O(n) + O(n*logn) 约等于 O(nlogn)*  空间复杂度：O(1)*/public void heapSort() {//1.建立大根堆 O(n)createHeap();//2.然后排序int end = usedSize-1;while (end > 0) {int tmp = elem[0];elem[0] = elem[end];elem[end] = tmp;shiftDown(0,end);end--;}}}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/234644.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

[安洵杯 2019]easy_web

[安洵杯 2019]easy_web

打开环境 img传参还有cmd img应该是base&#xff0c;先解码看看 3535352e706e67 这个好像是十六进制的&#xff0c;再解 访问一下看看&#xff0c;得到一张图片 尝试base解码&#xff0c;但是没有什么发现 再看看地址栏出现index.php,应该是要下载源码&#xff0c;但是还没有…
阅读更多...
kafka集群环境部署

kafka集群环境部署

文章目录 1 Kafka集群2 搭建两台服务器2.1 zookeeper部署2.2 启动1号机器的broker2.3 启动2号机器的broker2.4 查看kafka集群2.5 测试集群 1 Kafka集群 2 搭建两台服务器 2.1 zookeeper部署 zookeeper先只部署一台&#xff0c;在1号机器&#xff08;192.168.11.59&#xff09;…
阅读更多...
windows配置使用supervisor

windows配置使用supervisor

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、使用步骤1.安装supervisor-win2.配置supervisord3.配置program4.启动supervisord.exe5.supervisorctl.exe管控 二、后台启动总结 前言 windows使用supervi…
阅读更多...
基于Java+SpringBoot+Vue3+Uniapp+TypeScript(有视频教程)前后端分离的求职招聘小程序

基于Java+SpringBoot+Vue3+Uniapp+TypeScript(有视频教程)前后端分离的求职招聘小程序

博主介绍&#xff1a;✌全网粉丝5W&#xff0c;全栈开发工程师&#xff0c;从事多年软件开发&#xff0c;在大厂呆过。持有软件中级、六级等证书。可提供微服务项目搭建与毕业项目实战&#xff0c;博主也曾写过优秀论文&#xff0c;查重率极低&#xff0c;在这方面有丰富的经验…
阅读更多...
python技术栈之单元测试中mock的使用

python技术栈之单元测试中mock的使用

什么是mock&#xff1f; mock测试就是在测试过程中&#xff0c;对于某些不容易构造或者不容易获取的对象&#xff0c;用一个虚拟的对象来创建以便测试的测试方法。 mock的作用 特别是开发过程中上下游未完成的工序导致当前无法测试&#xff0c;需要虚拟某些特定对象以便测试…
阅读更多...
[python装饰器]什么是装饰器@

[python装饰器]什么是装饰器@

作者&#xff1a;20岁爱吃必胜客&#xff08;坤制作人&#xff09;&#xff0c;近十年开发经验, 跨域学习者&#xff0c;目前于新西兰奥克兰大学攻读IT硕士学位。荣誉&#xff1a;阿里云博客专家认证、腾讯开发者社区优质创作者&#xff0c;在CTF省赛校赛多次取得好成绩。跨领域…
阅读更多...
代码随想录算法训练营第30天|回溯总结 332. 重新安排行程

代码随想录算法训练营第30天|回溯总结 332. 重新安排行程

回溯是递归的副产品&#xff0c;只要有递归就会有回溯&#xff0c;所以回溯法也经常和二叉树遍历&#xff0c;深度优先搜索混在一起&#xff0c;因为这两种方式都是用了递归。 回溯法就是暴力搜索&#xff0c;并不是什么高效的算法&#xff0c;最多再剪枝一下。 回溯算法能解…
阅读更多...
手把手教会你--办公软件--Word--持续更新

手把手教会你--办公软件--Word--持续更新

有什么问题&#xff0c;请尽情问博主&#xff0c;QQ群796141573 1.1 Word排版基础1 保存和命名Ⅰ自动保存 2 建立标准的编辑环境(1)显示编辑标记(2)打开标尺(3)打开导航窗格 3 高效的鼠标/键盘手势(1)连续选中内容--shift(2)跳选内容--ctrl(3)矩形选择内容--alt(4)回到文档开头…
阅读更多...
半导体器件——MOS管

半导体器件——MOS管

半导体器件是导电性介于良导电体与绝缘体之间&#xff0c;利用半导体材料特殊电特性来完成特定功能的电子器件&#xff0c;可用来产生、控制、接收、变换、放大信 号和进行能量转换。 场效应晶体管是依靠一块薄层半导体受横向电场影响而改变其电阻(简称场效应)&#xff0c;使具…
阅读更多...
内模原理与控制

内模原理与控制

基于模型的控制方法&#xff1a; 把外部作用信号的动力学模型植入控制器来构成高精度反馈控制系统的设计原理。 内模原理&#xff08;IMP&#xff09;指的是&#xff0c;想要实现对R(s)的无差跟踪&#xff0c;系统的反馈回路中需要包含一个与外部输入R(s)相同的动力学模型。通…
阅读更多...
10.30 作业 C++

10.30 作业 C++

设计一个Per类&#xff0c;类中包含私有成员:姓名、年龄、指针成员身高、体重&#xff0c;再设计一个Stu类&#xff0c;类中包含私有成员:成绩、Per类对象p1&#xff0c;设计这两个类的构造函数、析构函数和拷贝构造函数。 #include <iostream>using namespace std;clas…
阅读更多...
2023/11/30JAVAweb学习

2023/11/30JAVAweb学习

数组json形式 想切换实现类,只需要只在你需要的类上添加 Component 如果在同一层,可以更改扫描范围,但是不推荐这种方法 注入时存在多个同类型bean解决方式
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023