优先级队列（堆）

已于 2024-03-12 23:39:54 修改
阅读量875 收藏 19
点赞数 19
分类专栏： 数据结构 文章标签： java 数据结构 算法
于 2024-03-12 23:38:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69468924/article/details/136649082
版权

目录

一、堆的性质

二、优先级队列的常用接口

三、PriorityQueue接口

1、使用PriorityQueue接口注意点

2、接口常用方法

3、改变接口的堆形式

4、Comparable接口与Comparator接口的区别

四、有关堆oj题目

1、一个普通序列建大根堆

2、一个普通序列建小根堆

3、大根堆中插入元素

4、小根堆中插入元素

5、大根堆中删除元素

6、小根堆中删除元素

7、大根堆排序--升序

8、小根堆排序--降序

9、max-top-k

10、min-top-k

一、堆的性质

1、堆总是一棵完全二叉树；

2、堆的所有元素按完全二叉树的顺序存储在一维数组中；

3、堆中某个结点的值总是小于父结点，其为大根堆；

4、堆中某个结点的值总是大于父结点，其为小根堆。

5、在数组中，若父结点下标为n，则左孩子为：2*n+1；右孩子为：2*n+2

二、优先级队列的常用接口

java集合框架提供了PriorityQueue和PriorityBlockIngQueue两种类型的优先级队列。PriorityQueue是线程不安全的，PriorityBlockIngQueue是线程安全的。

三、PriorityQueue接口

1、使用PriorityQueue接口注意点

①放置的元素必须能够比较大小，不能插入无法比较大小的对象；

②不能插入null对象；

③可以插入任意多个元素，内部可以自动扩容：数量<64,2倍扩容；数量>64,1.5倍扩容；数量>MAX_ARRAY_SIZE，按照MAX_ARRAY_SIZE来进行扩容；

④默认情况下是小堆，默认容量是11。

2、接口常用方法

3、改变接口的堆形式

①默认为小堆，改为大堆形式

②改为小堆形式

4、Comparable接口与Comparator接口的区别

相同点：都是用于实现自定义对象的比较。

①Comparable：在定义一个类时，可以直接实现该接口，重写compareTo方法。此时该类就可以直接比较大小了，一经定义，无法改变比较方式。

②Comparator：写一个比较器类实现了Comparator接口，重写compare方法。一个自定义类想比较大小，就可以直接用该比较器生成一个对象作为自定义类的参数。比较方式可以改变，选择不同的比较器。

四、有关堆oj题目

1、一个普通序列建大根堆

思路：从最后一个父结点开始，遍历完所有父结点，对每个父结点进行向下调整，直到没有孩子结点。

建堆的时间复杂度为：O(N)

import java.util.Arrays;

public class BigPriorityQueue {
    public static void buildPile(int[] a,int parent,int n){
        int child=2*parent+1;  //向下调整
        while(child<n){
            if(child+1<n&&a[child+1]>a[child]){
                child+=1;
            }
            if(a[child]>a[parent]){
                swap(a,parent,child);
                parent=child;
                child=2*parent+1;
            }else {
                break;
            }
        }
    }
    public static void swap(int[] array,int a,int b){
        int temp=array[a];
        array[a]=array[b];
        array[b]=temp;
    }

    public static void main(String[] args) {
        int[] a=new int[]{4,5,8,6,3,9,1};
        int n=a.length;
        int parent=(n-2)/2;
        for(int i=parent;i>=0;i--){  //遍历父结点
            buildPile(a,i,n);
        }
        System.out.println(Arrays.toString(a));
    }
}
2、一个普通序列建小根堆
import java.util.Arrays;

public class SmallPriorityQueue {
    public static void buildPile(int[] a,int parent,int n){
        int child=2*parent+1;  //向下调整
        while(child<n){
            if(child+1<n&&a[child+1]<a[child]){
                child+=1;
            }
            if(a[child]<a[parent]){
                swap(a,parent,child);
                parent=child;
                child=2*parent+1;
            }else {
                break;
            }
        }
    }
    public static void swap(int[] array,int a,int b){
        int temp=array[a];
        array[a]=array[b];
        array[b]=temp;
    }

    public static void main(String[] args) {
        int[] a=new int[]{4,5,8,6,3,9,1};
        int n=a.length;
        int parent=(n-2)/2;
        for(int i=parent;i>=0;i--){  //遍历父结点
            buildPile(a,i,n);
        }
        System.out.println(Arrays.toString(a));
    }
}

插入的时间复杂度为：O(logN)

3、大根堆中插入元素

思路：先将插入元素放在最后一个，只要不满足堆要求就向上调整，直到父结点为第一个父结点；若满足堆要求就结束。

import java.util.Arrays;

public class BigPriorityQueue {
    public static int[] add(int[] a, int num, int n) {
        int[] b = Arrays.copyOf(a, n + 1);
        b[n] = num;
        int child1 = n;
        while (child1 > 0) {
            int parent = (child1 - 1) / 2;
            if (b[child1] > b[parent]) {
                swap(b, child1, parent);
                child1 = parent;
            } else {
                break;
            }
        }
        return b;
    }
    public static void swap(int[] array,int a,int b){
        int temp=array[a];
        array[a]=array[b];
        array[b]=temp;
    }

    public static void main(String[] args) {
        int[] a=new int[]{9,6,8,5,3,4,1};
        int n = a.length;
        int[] b = add(a, 7, n);
        System.out.println(Arrays.toString(b));
    }
}
4、小根堆中插入元素
import java.util.Arrays;

public class SmallPriorityQueue {
    public static int[] add(int[] a, int num, int n) {
        int[] b = Arrays.copyOf(a, n + 1);  
        b[n] = num;
        int child1 = n;
        while (child1 > 0) {
            int parent = (child1 - 1) / 2;
            if (b[child1] < b[parent]) {
                swap(b, child1, parent);
                child1 = parent;         //向上调整
            } else {
                break;
            }
        }
        return b;
    }
    public static void swap(int[] array, int a, int b) {
        int temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }
    public static void main(String[] args) {
        int[] a = new int[]{1, 3, 4, 6, 5, 9, 8};
        int n = a.length;
        int[] b = add(a, 0, n);
        System.out.println(Arrays.toString(b));
    }
}
5、大根堆中删除元素

思路：删除堆顶元素，和最后一个位置交换，然后前n-1个元素以第一个父结点建堆。

删除的时间复杂度为：O(logN)

import java.util.Arrays;

public class BigPriorityQueue {
    public static int[] delete(int[] a, int n) {
        a[0] = a[n - 1];
        int[] b = Arrays.copyOf(a, n - 1);
        buildPile(b, 0, n - 1);
        return b;
    }
    public static void swap(int[] array, int a, int b) {
        int temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }
    public static void buildPile(int[] a, int parent, int n) {
        int child = 2 * parent + 1;  //向下调整
        while (child < n) {
            if (child + 1 < n && a[child + 1] > a[child]) {
                child += 1;
            }
            if (a[child] > a[parent]) {
                swap(a, parent, child);
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }
    public static void main(String[] args) {
        int[] a = new int[]{9, 6, 8, 5, 3, 4, 1};
        int n = a.length;
        int[] b = delete(a, n);
        System.out.println(Arrays.toString(b));
    }
}
6、小根堆中删除元素
public class SmallPriorityQueue {
    public static void buildPile(int[] a, int parent, int n) {
        int child = 2 * parent + 1;  //向下调整
        while (child < n) {
            if (child + 1 < n && a[child + 1] < a[child]) {
                child += 1;
            }
            if (a[child] < a[parent]) {
                swap(a, parent, child);
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }
    public static void swap(int[] array, int a, int b) {
        int temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }
    public static int[] delete(int[] a, int n) {
        a[0] = a[n - 1];
        int[] b = Arrays.copyOf(a, n - 1);
        buildPile(b, 0, n - 1);
        return b;
    }
    public static void main(String[] args) {
        int[] a = new int[]{1, 3, 4, 6, 5, 9, 8};
        int n = a.length;
        int[] b = delete(a, n);
        System.out.println(Arrays.toString(b));
    }
}
7、大根堆排序--升序

思路：将堆顶元素放在最后一个，前n-1个元素以第一个父结点建堆，接着交换......直到要交换的元素下标为0。

import java.util.Arrays;
public class BigPriorityQueue {
    public static void sort(int[] a, int n) {  //升序
        for (int i = n - 1; i > 0; i--) {
            swap(a, 0, i);
            buildPile(a, 0, --n);
        }
    }
    public static void buildPile(int[] a, int parent, int n) {
        int child = 2 * parent + 1;  //向下调整
        while (child < n) {
            if (child + 1 < n && a[child + 1] > a[child]) {
                child += 1;
            }
            if (a[child] > a[parent]) {
                swap(a, parent, child);
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }
    public static void swap(int[] array, int a, int b) {
        int temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }
    public static void main(String[] args) {
        int[] a = new int[]{9, 6, 8, 5, 3, 4, 1};
        int n = a.length;
        sort(a, n);
        System.out.println(Arrays.toString(a));
    }
}
8、小根堆排序--降序
import java.util.Arrays;
public class SmallPriorityQueue {
    public static void sort(int[] a, int n) {  //降序
        for (int i = n - 1; i > 0; i--) {
            swap(a, 0, i);
            buildPile(a, 0, --n);
        }
    }
    public static void buildPile(int[] a, int parent, int n) {
        int child = 2 * parent + 1;  //向下调整
        while (child < n) {
            if (child + 1 < n && a[child + 1] < a[child]) {
                child += 1;
            }
            if (a[child] < a[parent]) {
                swap(a, parent, child);
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }
    public static void swap(int[] array, int a, int b) {
        int temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }
    public static void main(String[] args) {
        int[] a = new int[]{1, 3, 4, 6, 5, 9, 8};
        int n = a.length;
        sort(a, n);
        System.out.println(Arrays.toString(a));
    }
}
9、max-top-k

思路：利用小根堆找出前k个最大的值。先将数组前k个元素建成小根堆，遍历数组后的数，只要比堆顶元素大，就和堆顶交换，前k个元素以第一个父结点建堆.....直到遍历完数组。可以不断筛选出较小值。

import java.util.Arrays;
public class SmallPriorityQueue {
    public static int[] maxTopK(int[] a, int n, int k) {
        if (k <= 0 || k > n) {
            return null;
        }
        if (k == n) {
            return a;
        }
        int[] b = Arrays.copyOf(a, k);
        if (k >= 2) {  //前k个建堆
            int parent = (k - 2) / 2;
            for (int i = parent; i >= 0; i--) {
                buildPile(b, i, k);
            }
        }
        for (int j = k; j < n; j++) {
            if (a[j] >= b[0]) {  //将元素小的筛选掉
                b[0] = a[j];
                buildPile(b, 0, k);
            }
        }
        return b;
    }
    public static void buildPile(int[] a, int parent, int n) {
        int child = 2 * parent + 1;  //向下调整
        while (child < n) {
            if (child + 1 < n && a[child + 1] < a[child]) {
                child += 1;
            }
            if (a[child] < a[parent]) {
                swap(a, parent, child);
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }
    public static void main(String[] args) {
        int[] a = new int[]{1, 3, 4, 6, 5, 9, 8};
        int n = a.length;
        int[] b = maxTopK(a, n, 3);
        System.out.println(Arrays.toString(b));
    }
}
10、min-top-k

思路：利用大根堆找出前k个最小的值。先将数组前k个元素建成大根堆，遍历数组后的数，只要比堆顶元素小，就和堆顶交换，前k个元素以第一个父结点建堆.....直到遍历完数组。可以不断筛选出较大值。

import java.util.Arrays;
public class BigPriorityQueue {
    public static int[] minTopK(int[] a, int n, int k) {
        if (k <= 0 || k > n) {
            return null;
        }
        if (k == n) {
            return a;
        }
        int[] b = Arrays.copyOf(a, k);
        if (k >= 2) {  //前k个建堆
            int parent = (k - 2) / 2;
            for (int i = parent; i >= 0; i--) {
                buildPile(b, i, k);
            }
        }
        for (int j = k; j < n; j++) {
            if (a[j] <= b[0]) {  //将元素大的筛选掉
                b[0] = a[j];
                buildPile(b, 0, k);
            }
        }
        return b;
    }
    public static void buildPile(int[] a, int parent, int n) {
        int child = 2 * parent + 1;  //向下调整
        while (child < n) {
            if (child + 1 < n && a[child + 1] > a[child]) {
                child += 1;
            }
            if (a[child] > a[parent]) {
                swap(a, parent, child);
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }
    public static void main(String[] args) {
        int[] a = new int[]{9, 6, 8, 5, 3, 4, 1};
        int n = a.length;
        int[] b = minTopK(a, n, 3);
        System.out.println(Arrays.toString(b));
    }
}

ambition…
关注
专栏目录
优先级队列(堆)
m0_63272315的博客
07-20 822
3.1 PriorityQueue的特性Java集合框架中提供了PriorityQueue和PriorityBlockingQueue两种类型的优先级队列，PriorityQueue是线 程不安全的，PriorityBlockingQueue是线程安全的，本文主要介绍PriorityQueue。关于PriorityQueue的使用要注意：1. 使用时必须导入PriorityQueue所在的包。
优先级队列 堆 PriorityQueue
qq_54219272的博客
10-26 1401
优先级队列（堆） 文章目录优先级队列（堆）一、概念1.1 堆的分类1.2向下调整1.3 建堆二、入队列2.1 向下调整三、出队列 前言 1、掌握堆的概念和实现 2、掌握PriorityQueue的使用 一、概念 堆逻辑上是一课完全二叉树，是用二叉树的层序遍历方式放入数组中，也就是说是用顺序数组来存储，这样可以节省空间。 重要公式： 1、已知父亲节点小标是i 左孩子下标：2*i+1； 右孩子下标：2*i+2； 2、已知孩子节点是j 求父亲节点的下标： 父亲节点下标：（j-1）/2 1.1 堆的分类
【Java 数据结构】优先级队列 (堆)
热门推荐
书生-w的博客
04-21 1万+
我们都学过队列，队列是一种先进先出的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列，这就是优先级队列。比如有时候我们在打游戏的时候，别人打电话给你，那么系统一定是先处理打进来的电话。
堆（优先级队列）
weixin_54342360的博客
03-28 1069
本文主要讲解堆的创建、向下调整、向上调整，PriorityQueue以及top-k问题
数据结构——优先级队列(堆)Priority Queue详解
Yuan_o_的博客
06-22 1444
优先级队列、堆模拟实现、存储方式、创建时间复杂度、插入和删除、堆常用接口、offer原理、PriorityQueue的扩容方式、top-k问题、堆排序
数据结构之优先级队列【堆】（Heap）
m0_58761900的博客
07-17 2758
（1）优先级队列底层是堆来实现的 （2）堆的本质是完全二叉树 ，堆有大根堆和小根堆 （3）大根堆：根节点最大的堆； 小根堆：根节点最小的堆 （6）top-K问题：前K个最大的元素建小根堆；前K个最小的元素建大根堆 第K个最大元素建小根堆 拿栈顶； 第K个最小元素建大根堆 拿栈顶 （7）堆排序：升序：大根堆 降序：小根堆 核心思想：堆元素的删除...
堆 和 优先级队列
Fighting！！！
04-10 971
堆、优先级队列、实现一个优先级队列、PriorityQueue的应用
C++优先级队列
qq_54178958的博客
08-17 4612
1、优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。2、此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。3、优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。4、底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。...
java优先级队列（堆）详解
2301_79783967的博客
04-21 1552
1、优先级队列的构造（无构造器）构造器功能介绍创建一个空的优先级队列，默认容量是11创建一个初始容量为initialCapacity的优先级队列，注意： initialCapacity不能小于1，否则会抛IllegalArgumentException异 常用一个集合来创建优先级队列//堆是队列实现的，叫优先级队列,数组实现//结果是5 所以默认是小根堆，也可以改为大根堆，以后讲//PriorityQueue是线程不安全的，PriorityBlockingQueue是线程安全的。
优先级队列（堆实现）
08-08
在Java中，优先级队列是通过`java.util.PriorityQueue`类来实现的，它基于一个二叉堆（Binary Heap）的数据结构。本文将深入探讨优先级队列的概念、实现方式以及如何在实际编程中使用。 首先，理解二叉堆是理解...
【数据结构】优先级队列（堆）
qq_52989768的博客
08-26 920
优先级队列依旧是队列，依旧遵循着先进先出的原则，不过和队列所不一样的是，优先级队列操作的数据有优先级，优先级高的数据先出队列，优先级队列底层所使用的数结构便是堆。
【数据结构】堆和优先级队列
m0_50987960的博客
12-02 890
堆的构建和基本方法的实现以及TopK问题。
详解优先级队列(堆)
ashfiqa的博客
10-16 953
一、堆的概念以及堆的创建 1、堆的概念 什么是堆？（堆的逻辑上是一个完全二叉树，实际上是保存在数组中） 我们把一个完全二叉树通过层序遍历存储到数组当中，这个数组就叫做堆。 注意：堆中的元素不能为空。(浪费大量空间) 什么是大根堆和小根堆？ 大根堆：所有结点的值都大于其子结点的值，我们称为大根堆。 小根堆：所有结点的值都小于其子结点的值，我们称为小根堆。 注意：父亲结点为i时，左孩子的结点为i*2+1，右孩子的结点为i*2+2; 孩子结点为i时...
JDK1.0主要特性
FoolRabbit的专栏
10-06 292
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 494
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Puppeteer自动化：使用JavaScript定制PDF下载
最新发布
ip16yun的博客
10-08 488
Puppeteer 是一个强大的Node.js库，提供了对无头Chrome或Chromium的控制，可以用于生成网页快照、抓取数据、自动化测试等任务。其中，生成PDF文件是一个常见的需求，本文将通过使用Puppeteer展示如何自动化生成定制的PDF，并使用代理IP、设置user-agent、cookie等技术来增强自动化过程的灵活性与稳定性。为了更好地理解如何定制Puppeteer生成的PDF文件，我们提供一个生成A4纸张格式的网页PDF的实例。用户可以根据需求自定义输出的PDF格式或内容。
Java内存布局
阿呆的专栏
10-01 829
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 941
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ambition…

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

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

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

打赏作者

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

抵扣说明：

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

余额充值