优先级队列（堆）

最新推荐文章于 2024-10-11 17:30:36 发布
最新推荐文章于 2024-10-11 17:30:36 发布
阅读量526 收藏
点赞数 1
分类专栏： java 笔记 文章标签： java 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengxia110/article/details/128751677
版权
java 同时被 2 个专栏收录
51 篇文章 0 订阅
订阅专栏
笔记
45 篇文章 0 订阅
订阅专栏

1.优先级队列

1.1概念

前面介绍过队列，队列是一种先进先出（FIFO）的数据结构，但是有些情况下，操作的数据可能带有优先级时，可能需要优先级高的元素先入队列，该场景中，使用队列显然不合适，比如在手机上玩游戏的时候，如果有来电，我们应当让系统先处理打进来的电话；在学校排座位的时候，可以先让部分成绩好的选作为，再让从低到高的同学选座位。

在这种情况下，数据结构应当提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列（Priority Queue)

2.优先级队列的模拟实现

JDK1.8的PreorityQueue底层使用了堆这种数据结构，而堆实际就是在完成完全二叉树的基础上进行了一些调整。

2.1堆的概念

如果有一个关键码的集合K={k0,k1,k2,...,kn-1}，把它的所有元素按照完全二叉树的顺序储存方式储存在一个一维数组中，并满足ki<=k2i+1且ki<=k2i+2或ki>=k2i+1且ki>=k2i+2，i=0,1,2...，则称为小堆或大堆。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

【堆的性质】

  • 堆中某个节点的值总是不大于或不小于其父节点的值；

  • 堆总是一颗完全二叉树。

2.2堆的储存方式

从堆的概念可知，堆是一颗完全二叉树，因此可以层序的规则采取顺序的方式来高效储存。

【注意】对于 非完全二叉树，则不适用使用顺序方式来储存，因为普通二叉树的有很多的节点是null,我们需要表示出来一些位置为空，这将会导致对于 空间的利用率很低，有很多的空间只是为了占位置。

将元素储存到数组中后，可以根据二叉树章节的性质对树进行还原。假设i为节点在数组中的下标，则有

  • 如果i为0，则i表示的节点为根节点，否则i的双亲节点为(i-1)/2;

  • 如果2*i+1小于节点个数，则节点i的左孩子节点下标是2*i+1,否则没有左孩子；

  • 如果2*i+2小于节点个数，则则节点i的右孩子节点下标是2*i+2,否则没有右孩子。

2.3堆的创建

2.3.1堆向下调整

对于集合{27,15,19,18,28,34,65,49,25,37}中的数据，我们如何将其创建成堆呢？（以创建小根堆为例）

向下调整过程（以小根堆为例）：

  • 让parent标记需要调整的节点，child标记parent的左孩子（注意：我们要判断是否有左孩子）

  • 如果parent的左孩子存在，即child<size，进行以下操作，直到parent的左孩子不存在

  1. parent的右孩子是否存在，存在找到左右孩子中最小的孩子，用child进行标记；

  1. 将parent与较小的孩子进行child进行比较，看是否需要调整：如果调整，我们进行调整后，让parent=child，在进行同样的循环，直到不交换元素或没有孩子节点。

public class Test {
    //向下调整，小根堆
    public void shiftDown(int[] array, int parent) {
        int size = array.length;
        if(size == 0) {
            return;
        }
        int child = parent * 2 + 1;
        int tmp;
        while(child < size) {
            if(child + 1 < size && array[child] > array[child + 1]) {
                child++;
            }
            if(array[child] < array[parent]) {//孩子小，进行交换
                tmp = array[parent];
                array[parent] = array[child];
                array[child] = tmp;
                parent = child;
                child = parent * 2 + 1;
            }else {
                break;
            }
        }
    }

    public static void main(String[] args) {
        Test t = new Test();
        int[] array = new int[]{ 27,15,19,18,28,34,65,49,25,37 };
        t.shiftDown(array, 0);
        System.out.println(Arrays.toString(array));
    }
}

【注意】在调整以parent为根的二叉树时，必须要满足parent的左子树和右子树已经是堆了才可以向下调整。

最坏的情况：从根一路比较到叶子，比较的次数为完全二叉树的高度，即时间复杂度为O(log2N)

2.3.2堆的创建

对于普通的队列，如{1，5，3，8，7，6}，即根节点的左右子树不满足堆的特性，又该如何调整呢？

//堆的创建
    public void createHeap(int[] array) {
        //找到第一个要调整的父节点
        int root = ((array.length - 2) >> 1);
        for (int i = root; i >= 0; i--) {
            shiftDown(array, i);
        
    }
public static void main(String[] args) {
        int[] array1 = new int[]{1,5,3,8,7,6 };
        t.createHeap(array1);
        System.out.println(Arrays.toString(array1));
    }

2.3.3建堆的时间复杂度

为了简化，我们使用满二叉树来进行时间复杂度的计算。

2.4根的插入和删除

2.4.1堆的插入

堆的插入总共需要两个步骤：

  1. 先将元素放入到底层的空间中（注意：空间不足时要进行扩容）；

  1. 将最后新插入的元素向上调整，直到满足堆的性质。

//向上调整 小根堆
    public void shiftUp(int[] array, int child) {
        if(child <= 0) {
            return;
        }
        int parent;
        while(child > 0) {
            parent = (child - 1) / 2;
            if(array[child] < array[parent]) {
                int tmp = array[child];
                array[child] = array[parent];
                array[parent] = tmp;
                child = parent;
            }
            else {
                return;
            }
        }
    }

【解释】我们如果在小根堆中，再放入一个元素，我们使用向上调整即可，再次获得小根堆。

2.4.2堆的删除

【注意】堆的删除一定是堆顶的元素（最大值或最小值）。具体如下：

  1. 将堆顶元素对堆中最后一个元素交换；

  1. 将队中有效数据个数减少一个；

  1. 堆顶元素进行向下调整。

2.5用堆模拟实现优先级队列

package Demo;

import java.util.Arrays;

/**
 * Describe:模拟实现优先级队列
 * User:lenovo
 * Date:2023-01-25
 * Time:19:51
 */
public class MyPriorityQueue {
    private int[] array = new int[11];//在实际中也是默认为11；
    private int size = 0;

    //插入元素
    public void offer(int e) {
        if(size == array.length) {
            if(size == 0) {
                array[0] = e;
                size++;
                return;
            }
            else{
                array = Arrays.copyOf(array, 2*array.length);
            }
        }
        array[size++] = e;
        //向上调整
        shiftUp(array, size - 1);
    }
    private void shiftUp(int[] array, int child) {
        if(child <= 0) {
            return;
        }
        int parent;
        while(child > 0) {
            parent = (child - 1) / 2;
            if(array[child] < array[parent]) {
                int tmp = array[child];
                array[child] = array[parent];
                array[parent] = tmp;
                child = parent;
            }
            else {
                return;
            }
        }
    }

    //删除元素
    public int poll() {
        if(size == 0) {
            throw new RuntimeException("优先级队列为空");
        }
        int ret = array[0];
        size--;
        array[0] = array[size];
        shiftDown(array, 0);
        return ret;
    }
    //向下调整，小根堆
    private void shiftDown(int[] array, int parent) {
        int size = array.length;
        if(size == 0) {
            return;
        }
        int child = parent * 2 + 1;
        int tmp;

        while(child < size) {
            if(child + 1 < size && array[child] > array[child + 1]) {
                child++;
            }
            if(array[child] < array[parent]) {//孩子小，进行交换
                tmp = array[parent];
                array[parent] = array[child];
                array[child] = tmp;
                parent = child;
                child = parent * 2 + 1;
            }else {
                break;
            }
        }
    }

    //查看堆顶元素
    public int peek() {
        if(size == 0) {
            throw new RuntimeException("优先级队列为空");
        }
        return array[0];
    }

    //开始检测
    public static void main(String[] args) {
        MyPriorityQueue a = new MyPriorityQueue();
        a.offer(1);
        a.offer(2);
        a.offer(3);
        System.out.println(a.poll());
        System.out.println(a.poll());
    }
}

【常见习题】

1. 下列关键字序列为堆的是（）
A: 100,60,70,50,32,65 B: 60,70,65,50,32,100 C: 65,100,70,32,50,60
D: 70,65,100,32,50,60 E: 32,50,100,70,65,60 F: 50,100,70,65,60,32
2. 已知小根堆为8,15,10,21,34,16,12，关键字8删除后重新建队，在这过程中需要比较的次数是（3）
3. 最小堆[0,3,2,5,7,4,6,8],在删除栈顶元素0之后，其结果是（[2,3,4,5,7,8,6]）

3.常见的接口

3.1PriorityQueue的特性

Java集合框架中提供了PriorityQueue和PriorityBlockingQueue两种类型的优先级队列，PriorityQueue是线程不安全的，PriorityBlockingQueue是线程安全的，本文主要介绍PriorityQueue.

关PriorityQueue的使用要注意：

  1. 使用时必须要导入PriorityQueue所在的包，即：

import java.util.PriorityQueue;

  1. PriorityQueue中放置的元素必须要能够比较大小，不能插入无法比较大小的对象，否则就会抛出ClassCastException异常

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

  1. 没有容量的限制，可以插入任意多个元素，其内部空间可以自动扩容；

  1. 插入和删除元素的时间复杂度都是O(log2N);

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

  1. PriorityQueue默认情况下是小堆——即每次获取到的元素都是最小的元素；

3.2 ProrityQueue常用接口介绍

1.优先级队列的构造

此处只介绍几种常用的构造方法：

构造器

功能

PriorityQueue（）

创建一个空的优先级队列，默认容量是11

PriorityQueue(int

initialCapacity)

创建一个初始容量为initialCapacity的优先级队列，注意：initicalCapacity不能小于1，否则将会抛出IIIegalArgumentException异常

PriorityQueue(Collection<? extends E> c)

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

public static void main(String[] args) {
        //创建一个空的优先级队列，默认容量为11
        PriorityQueue<Integer> q1 = new PriorityQueue<>();
        //创建一个空的优先级队列，容量为给定值
        PriorityQueue<Integer> q2 = new PriorityQueue<>(100);//大小为100

        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);

        //用ArrayList对象来构造一个优先级队列的对象
        //q3中已经包含了三个元素
        PriorityQueue<Integer> q3 = new PriorityQueue<>(list);
        System.out.println(q3.size());
        System.out.println(q3.peek());
    }

默认情况下，PriorityQueue队列为小堆，如果需要大堆需要用户提供比较器。

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

//直接实现Comparator接口，来实现大根堆
class IntCmp implements Comparator<Integer> {
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
}

public class Test {
    public static void main(String[] args) {
        PriorityQueue<Integer> p = new PriorityQueue<>(new IntCmp());
        p.offer(1);
        p.offer(2);
        p.offer(3);
        p.offer(4);
        p.offer(5);

        System.out.println(p.peek());
    }
}

我们直接将在创建优先级队列的时候，把比较器给它就行；

此时创建出来的就是一个大根堆。

2.插入/删除/获取优先级队列

函数名

功能介绍

boolean offer(E e)

插入元素e,插入成功返回true,如果e对象为空，将抛出NullPointerException异常，时间复杂度O(log2N),注意空间不够时候会进行自动扩容。

E peek()

获取优先级最高的元素，如果优先级队列为空，返回null

E pool()

移除优先级最高的元素并返回，如果优先级队列为空，返回null

int size()

获取有效元素的个数

void clear()

清空所有内容

boolean isEmpty()

检测优先级队列是否为空，空返回true

优先级队列的扩容说明：

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

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

  • 如果容量超过MAX_ARRAY_SIZE，按照MAX_ARRAY_SIZE来进行扩容的。（大概为21亿多）

3.3 OJ练习

获取堆中前k个最大值(或最小值）。（时间复杂度尽可能的低）

import java.util.PriorityQueue;
class IntCmp implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
}
class Solution {
    public int[] smallestK(int[] arr, int k) {
    PriorityQueue<Integer> q = new PriorityQueue<>(new IntCmp());
        int[] ret = new int[k];
        if(arr == null || k <= 0) {
            return ret;
        }
        for (int i = 0; i < k; i++) {
            q.offer(arr[i]);
        }
        int size = arr.length;
        for (int i = k; i < size; i++) {
            if(q.peek() > arr[i]) {
                q.poll();
                q.offer(arr[i]);
            }
        }
        int i = 0;
        while(!q.isEmpty()) {
            ret[i++] = q.poll();
        }
        return ret;
    }
}

【解析】

  • 我们以前k个最小值举例；

  • 我们需要的是K个元素大小的空间，用于存放最小值（我们并不需要多大空间，再多的空间实际上我们并用不到后面的数据。我们使用大根堆进行存放，大根堆里存放最小值，arr[0]是最小值中的最大值，我们只需要和它比较即可。

  • 我们先存放前k个元素，放入堆中;

  • 数组后面的元素，我们都要与堆的首元素进行比较（这是堆的最大的数）；如果q.peek()>array[i]，我们删除首元素，插入array[i];反之，无操作

4.堆的应用

4.1ProrityQueue的实现

用堆最为底层结构封装优先级队列

4.2 堆排序

堆排序即利用堆的思想来进行排序，总共分为两个步骤

  1. 建堆

  • 升序：建大堆

  • 降序：建小堆

2.利用堆删除思想来进行排序

建堆和堆删除中都用到了向下调整，因此掌握向下调整，就可以完成堆排序

【常见习题】

，1.一组记录排序码为（5，11，7，2，3，12），利用堆排序的方法建立的初始堆为（17，11，7，2，3，5）

4.3 Top-k问题

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

比如：世界500前、富豪榜、游戏中前100的活跃玩家等

对于Top-K问题，能想到的最简单方法是直接排序，但是数据量过大，排序是很麻烦的。最佳的方式就是用堆来解决，基本思路（上面3.3）

C语言的好男友
关注
专栏目录
C语言实现优先队列、二叉堆和堆排序
ZER00000001的博客
07-07 1199
查找和排序是数据结构与算法中不可或缺的一环，是前辈们在算法道路上留下的重要且方便的一些技巧，学习这些经典的查找和排序也能让我们更好和更快的解决问题。在这个专栏中我们会学习六大查找和十大排序的算法与思想，而本篇将详细讲解其中的堆排序；...
c++ 优先队列(priority_queue)
m0_54853420的博客
06-08 396
对于这个模板类priority_queue，它是STL所提供的一个非常有效的容器。作为队列的一个延伸，优先队列包含在**头文件**中C ++中的优先队列是STL中的派生容器，它仅考虑最高优先级元素。队列遵循FIFO策略，而优先队列根据优先级弹出元素，即，优先级最高的元素首先弹出。它在某些方面类似于普通队列，但在以下方面有所不同：注意：优先队列是普通队列的扩展版本，但优先级最高的元素将首先从优先队列中删除。大顶堆（降序）小顶堆（升序）我们通过使用push()函数插入元素，并且插入操作与普通队列相同。但是，当我
优先级队列和堆
yahid的博客
06-21 1034
优先级队列:返回最高优先级对象、添加新的对象 堆:将一个给定的集合或数组里面的元素按照完全二叉树层序遍历的顺序存储在一个一维数组中 堆的存储方式:大根堆、小根堆 大根堆:每个节点都大于左右子节点 小根堆:每个节点都小于左右子节点 模拟实现优先级队列(堆)的创建: 思路:堆的向下调整 1.从最后一科子树开始调整 2.每颗子树调整的时候都是向下调整 主要解决问题: (1)确定最后一课子树的根节点p = [(len-1)-1]/2 (2)p-- (3)堆向下调整，确保左右子节点<l.
【数据结构】优先级队列 - 堆
weixin_61543874的博客
07-05 473
数据结构- 堆
【STL】优先级队列剖析及模拟实现
阿润菜菜的博客
03-30 2829
关于优先级队列剖析及模拟实现
优先级队列(堆)
m0_63272315的博客
07-20 825
3.1 PriorityQueue的特性Java集合框架中提供了PriorityQueue和PriorityBlockingQueue两种类型的优先级队列，PriorityQueue是线 程不安全的，PriorityBlockingQueue是线程安全的，本文主要介绍PriorityQueue。关于PriorityQueue的使用要注意：1. 使用时必须导入PriorityQueue所在的包。
优先级队列 堆 PriorityQueue
qq_54219272的博客
10-26 1409
优先级队列（堆） 文章目录优先级队列（堆）一、概念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 堆的分类
优先级队列（堆实现）
08-08
在Java中，优先级队列是通过`java.util.PriorityQueue`类来实现的，它基于一个二叉堆（Binary Heap）的数据结构。本文将深入探讨优先级队列的概念、实现方式以及如何在实际编程中使用。 首先，理解二叉堆是理解...
【数据结构】优先级队列（堆）
qq_52989768的博客
08-26 926
优先级队列依旧是队列，依旧遵循着先进先出的原则，不过和队列所不一样的是，优先级队列操作的数据有优先级，优先级高的数据先出队列，优先级队列底层所使用的数结构便是堆。
【数据结构】堆和优先级队列
m0_50987960的博客
12-02 898
堆的构建和基本方法的实现以及TopK问题。
详解优先级队列(堆)
ashfiqa的博客
10-16 958
一、堆的概念以及堆的创建 1、堆的概念 什么是堆？（堆的逻辑上是一个完全二叉树，实际上是保存在数组中） 我们把一个完全二叉树通过层序遍历存储到数组当中，这个数组就叫做堆。 注意：堆中的元素不能为空。(浪费大量空间) 什么是大根堆和小根堆？ 大根堆：所有结点的值都大于其子结点的值，我们称为大根堆。 小根堆：所有结点的值都小于其子结点的值，我们称为小根堆。 注意：父亲结点为i时，左孩子的结点为i*2+1，右孩子的结点为i*2+2; 孩子结点为i时...
优先级队列——二叉堆和最大堆
m0_68989458的博客
05-18 423
优先级队列初识，二叉堆和最大堆讲解
priority_queue
热门推荐
PZHU_CG_CSDN的博客
01-25 2万+
priority_queue　　priority_queue 优先队列，其底层是用堆来实现的。在优先队列中，队首元素一定是当前队列中优先级最高的那一个。　　在优先队列中，没有 front() 函数与 back() 函数，而只能通过 top() 函数来访问队首元素（也可称为堆顶元素），也就是优先级最高的元素。一、基本数据类型的优先级设置 此处指的基本数据类型就是 int 型，double 型，char
在STL优先队列中查找
小埋
11-06 5263
在C++的priority_queue中实现查找。
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1396
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
JDK1.0主要特性
FoolRabbit的专栏
10-06 760
JDK1.0主要特性。
Backend - Java 基础
最新发布
是萝卜干呀的博客
10-11 444
知识量决定了未来能走多远
2024Java最新面试题总结（针对于一些小厂、中厂）
weixin_62375676的博客
10-07 1644
2024最新Java面试题，针对一些小厂，中厂
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值