数据结构 优先级队列（堆）

已于 2022-06-29 10:07:48 修改
阅读量363 收藏 2
点赞数 7
文章标签： java 数据结构 开发语言
于 2022-06-28 15:54:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ttthe_shy_/article/details/125424303
版权

文章目录

一、概念

1.1类比现实生活

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.2与普通队列区别

在这里插入图片描述

二、基于二叉树的堆的特点

2.1关于存储结构

完全二叉树一般采用数组结构存储
在这里插入图片描述

2.2关于节点值

在这里插入图片描述
是否层次越高，根的节点值一定越大？
在这里插入图片描述
在这里插入图片描述

2.3关于节点的编号

在这里插入图片描述

2.4判断堆的条件

在这里插入图片描述

三、堆的三大核心操作

代码示例如下

/**
 * 基于动态数组实现最大堆
 * @author hide_on_bush
 * @date 2022/6/24
 **/
public class MaxHeap {
    //动态数组存储元素
    private List<Integer> data;
    //当前堆中元素个数
    private int size;

    public boolean isEmpty(){
        return size==0;
    }

    public int getSize(){
        return size;
    }

    /**
     * 找到节点k对应的父节点索引
     * */
    private int parent(int k){
        return (k-1)>>1;
    }
    /**
     * 找到节点k对应的左子树索引
     * */
    private int leftChild(int k) {
        return (k<<1)+1;
    }
    /**
     * 找到节点k对应的右子树索引
     * */
    private int rightChild(int k) {
        return (k<<1)+2;
    }
}

3.1堆中添加元素 siftUp

在这里插入图片描述
新增元素的变化过程：

在这里插入图片描述

在这里插入图片描述
对应代码：
易错点提示：1.动态数组获取元素只能调用方法，不能简单的data[索引值]
2.交换元素也不能使用交换三连，而是调用方法

//添加元素siftUp
    public void add(int val){
        //动态数组add方法默认是尾插法
        data.add(val);
        size++;
        //添加完元素进行上浮操作
        siftUp(size-1);
    }

    private void siftUp(int i) {
        //上浮操作的两个终止条件
        //1.已上浮到根节点的位置
        //2.当前索引的节点值大于当前索引的父节点值
        while(i>0&& data.get(i) > data.get(parent(i))){
            swap(i,parent(i));
            i=parent(i);
        }
    }

    //交换元素
    private void swap(int i, int parent) {
        int child=data.get(i);
        int parentVal=data.get(parent);
        data.set(i,parentVal);
        data.set(parent,child);
    }

总结：
在这里插入图片描述

3.2 最大堆获取最大值

在这里插入图片描述
在这里插入图片描述
核心思路：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/**
     * 取出堆中最大值
     * */
    public int extractMax(){
        if(size==0){
            throw new NoSuchElementException("heap is empty!");
        }
        //取出最大值，根节点
        int max=data.get(0);
        //将数组末尾顶到堆顶
        data.set(0, data.get(size-1));
        //删除堆中末尾元素
        data.remove(size-1);
        size--;
        //将末尾元素进行下沉操作
        siftDown(0);
        return max;
    }

    private void siftDown(int i) {
        //判断是否存在左子树
        while(leftChild(i)<size){
            int j=leftChild(i);
            //此时存在右子树，且值比左子树大
            if(j+1<size&&data.get(j+1)>data.get(j)){
                j++;
            }
            //此时索引位置一定对应左右子树最大值的索引
            if(data.get(i)>= data.get(j)){
                //当前元素大于左右子树最大值，元素下沉结束
                break;
            }else{
                swap(i,j);
                i=j;
            }
        }
    }

    //交换元素
    private void swap(int i, int parent) {
        int child=data.get(i);
        int parentVal=data.get(parent);
        data.set(i,parentVal);
        data.set(parent,child);
    }

3.3 堆化 heapify（重点掌握思想）

在这里插入图片描述
第一种方法：构建一个新的最大堆，直接调用最大堆的add方法

时间复杂度为：nlogn，n代表遍历原数组，logn代表在二叉树中添加元素
空间复杂度为：O(n)，因为开辟了新的空间
在这里插入图片描述
第二种方法：原地堆化

核心思想：从最后一个非叶子节点开始进行siftDown操作
原因依次从最后一棵子树开始调整为最大堆的子最大堆
在这里插入图片描述
注意事项：自底向上建堆是一个时间复杂度近似O（n）的方法
在这里插入图片描述

//原地堆化
    public MaxHeap(int[] arr){
        //将所有元素复制到data
        data=new ArrayList<>(arr.length);
        for (int i:arr){
            data.add(i);
            size++;
        }
        //从最后一个非叶子节点进行下沉操作
        //没有parent方法就（size-1-1）/2
        for (int i = parent(size-1); i >=0 ; i--) {
            siftDown(i);
        }
    }

3.3 拓展：java对象比较方法

java大小关系比较：
在这里插入图片描述

comparaTo接口弊端

每次根据需求就必须更改源代码，因为不同场景下大小关系是不确定的
在这里插入图片描述

comparator接口

每次不同的需求就创建关于这个类的不同的比较器，实现不同的需求
在这里插入图片描述
在这里插入图片描述
核心思想：不碰原来写过的代码，需要怎么比较就新创建一个类，一个类就是一种比较方法。对其它比较方法不影响

//这个类是根据年龄越大就越大进行比较
class StudentSec implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getAge()-o2.getAge();
    }
}

//这个类是根据是年龄越大反而越小的类
class StudentDesc implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o2.getAge()-o1.getAge();
    }
}

public class Student {
    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public Student(int age) {
        this.age = age;
    }

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    public static void main(String[] args) {
        Student[] students=new Student[]{
                new Student(19,"may"),
                new Student(20,"rose"),
                new Student(21,"jack")
        };
        //得到一个按年龄升序数组
        //student这个类不具备可比较的能力，传入比较器
        Arrays.sort(students,new StudentSec());
        System.out.println(Arrays.toString(students));
        //按年龄降序的数组
        Arrays.sort(students,new StudentDesc());
        System.out.println(Arrays.toString(students));
    }
}

四、基于堆的优先级队列的应用

4.1TopK问题（重点掌握）

在这里插入图片描述
第一种方法的时间复杂度是nlogn：仅供参考，不推荐使用

//时间复杂度为nlogn的算法
    public int[] smallestTop4(int[] data,int k){
        Arrays.sort(data);
        int[] ret=new int[k];
        for (int i = 0; i < k; i++) {
            ret[i]=data[i];
        }
        return ret;
    }

第二种方法时间复杂度近似O（n）但还是nlogk（重点掌握）：
在这里插入图片描述
注意事项：1.边界条件有两个，一个判断数组为空，还有一个判断k==0
2.jdk默认的优先级队列是最小堆，要传入比较器对象变成最大堆

/**
 * 最小k个数
 * @author hide_on_bush
 * @date 2022/5/22
 */
public class Num17_14SmallestK {
    public int[] smallestK(int[] arr, int k) {
        int[] ret = new int[k];
        //边界条件别忘记k=0
        if(arr.length==0||k==0){
            return ret;
        }
        //内部类传入一个比较器对象，因为JDK默认最小堆
        //传入比较器后默认值越大反而越小排在队列之前
        Queue<Integer> queue=new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        //遍历数组集合
        for (int i = 0; i < arr.length; i++) {
            if(queue.size()<k){
                queue.offer(arr[i]);
            }else{
                int max=queue.peek();
                if(arr[i]<max){
                    queue.poll();
                    queue.offer(arr[i]);
                }
            }
        }
        int i=0;
        while(!queue.isEmpty()){
            ret[i++]=queue.poll();
        }
        return ret;
    }
拓展：内部类（匿名内部类）

实际上就是 class 无引用名称=new 接口（向上转型）
在这里插入图片描述

4.2 leetcode347号问题

在这里插入图片描述
难点：
在这里插入图片描述
补充支持：Map集合遍历方法
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
核心思路：
1.原数组扫描，将出现的元素和元素出现的频次保存到map集合
2.再扫描Map集合，将结果放入优先级队列中（最小堆）
3.遍历队列，将最大频次结果依次出队

几个关键点：
1.使用map是为了方便记录键值对
2.使用自定义类是为了方便保存在队列中

/**
 * @author hide_on_bush
 * @date 2022/6/27
 */
//在优先级队列中添加该元素对象即可
class Freq implements Comparable<Freq>{
    //数组出现的元素
    int key;
    //key出现的次数
    int value;

    public Freq(int key, int value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public int compareTo(Freq o) {
    //谁出现的频次越大就越大
        return this.value-o.value;
    }
}

public class Num347_TopKK {
    public int[] topKFrequent(int[] nums, int k) {
        //返回的结果集
        int[] data=new int[k];
        //1.先扫描原数组，将出现元素保存到map集合,保存的是entry对象
        Map<Integer,Integer> map=new HashMap<>();
        for (int i:nums) {
            if(map.containsKey(i)){
                //此时元素i出现过,频次++
                //获取该元素i出现的频次
                int times=map.get(i);
                map.put(i,times+1);
            }else{
                //第一次出现，将元素保存map集合，频次设置为1
                map.put(i,1);
            }
        }
        //2.遍历map集合，找出频次最高的k次个元素保存到优先级队列中
        Queue<Freq> queue=new PriorityQueue<>();
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
            if(queue.size()<k){
                queue.offer(new Freq(entry.getKey(),entry.getValue()));
            }else{
                //判断当前元素和堆顶元素出现的频次
                //当前元素出现频次大于堆顶元素的频次，入队
                Freq freq= queue.peek();
                if(entry.getValue()> freq.value){
                    queue.poll();
                    queue.offer(new Freq(entry.getKey(), entry.getValue()));
                }
            }
        }
        //此时队列保存出现频次最高的k个元素
        int index=0;
        while (!queue.isEmpty()) {
            data[index++] =queue.poll().key;
        }
        return data;
    }
}

注意事项：每次出队或者入队需要Freq对象，而不是简单的把key或者value数值简单的输出

4.3leetcode373 最小对元素

添加链接描述
在这里插入图片描述
注意事项：1.优先级队列保存的还是一对数（最大堆）
在这里插入图片描述
2.循环终止条件：应该是k和数组长度两者的最小值，因为这是有序排序，最小值一定是在k之前或者数组长度之前（在谁之前看两者大小关系）
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/**
 * 和最小的k个数对 - 用最大堆
 * @author yuisama
 * @date 2022/05/18 19:39
 **/
public class Num373_KSmallestPairs {
    public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {
        // 1.创建优先级队列，其中队列中保存Pair对象，传入比较器，和越小反而越大
        Queue<Pair> queue = new PriorityQueue<>(new Comparator<Pair>() {
        //最大堆，反而最上面的值越大
            @Override
            public int compare(Pair o1, Pair o2) {
                return (o2.u + o2.v) - (o1.u + o1.v);
            }
        });
        // 2.遍历两个数组，其中u来自第一个数组，v来自第二个数组
        // 队列中保存了和最小的k个数对
        for (int i = 0; i < Math.min(nums1.length,k); i++) {
            for (int j = 0; j < Math.min(nums2.length,k); j++) {
                if (queue.size() < k) {
                    queue.offer(new Pair(nums1[i],nums2[j]));
                }else {
                    int add = nums1[i] + nums2[j];
                    Pair pair = queue.peek();
                    if (add < (pair.u + pair.v)) {
                        queue.poll();
                        queue.offer(new Pair(nums1[i],nums2[j]));
                    }
                }
            }
        }
        // 3.此时队列中就保存了和最小的前k个Pair对象，取出其中u和v即可
        List<List<Integer>> ret = new ArrayList<>();
        while (!queue.isEmpty()) {
            List<Integer> temp = new ArrayList<>();
            Pair pair = queue.poll();
            temp.add(pair.u);
            temp.add(pair.v);
            ret.add(temp);
        }
        return ret;
    }
}
//保存在优先级队列中的对象
class Pair {
    // 来自数组1
    int u;
    // 来自数组2
    int v;

    public Pair(int u, int v) {
        this.u = u;
        this.v = v;
    }
}

4.5原地堆排序

在这里插入图片描述
不使用最小堆的原因：层次的深度和大小无关，最小堆按编号顺序不一定是升序

/**
 * 七大排序
 * @author yuisama
 * @date 2022/05/18 20:21
 **/
public class SevenSort {
    public static void main(String[] args) {
        int[] arr = {19,27,13,22,3,1,6,5,4,2,110,65,70,98,72};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    // 原地堆排序
    public static void heapSort(int[] arr) {
        // 1.先将任意数组进行heapify调整为最大堆
        for (int i = (arr.length - 1 - 1) / 2; i >= 0; i--) {
            siftDown(arr,i,arr.length);
        }
        // 2.不断交换堆顶元素到数组末尾，每交换一个元素，就有一个元素落在了最终位置
        for (int i = arr.length - 1; i > 0; i--) {
            // arr[i] 就是未排序数组的最大值，交换末尾
            swap(arr,0,i);
            siftDown(arr,0,i);
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    /**
     * 元素下沉操作
     * @param arr
     * @param i 下沉的索引
     * @param length 数组的长度
     */
    private static void siftDown(int[] arr, int i, int length) {
        while (2 * i + 1 < length) {
            int j = 2 * i + 1;
            if (j + 1 < length && arr[j + 1] > arr[j]) {
                j = j + 1;
            }
            if (arr[i] >arr[j]) {
                break;
            }else {
                swap(arr,i,j);
                i = j;
            }
        }
    }
}
不会写代码_
关注
  • 7
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
数据结构-优先级队列(堆)
2201_75919566的博客
01-26 143
数据结构-优先级队列(堆)
数据结构-堆（优先队列）
06-18 3406
判断题 1.任何最小堆的前序遍历结果是有序的（从小到大）。 T F 2.任何最小堆中从根结点到任一叶结点路径上的所有结点是有序的（从小到大）。 T F 3.在有N个元素的最大堆中，随机访问任意键值的操作可以在O(logN)时间完成。 T ...
优先级队列
姑苏
03-20 374
前言： 优先级队列，数据结构是堆，存储元素呢一般用数组存储。前面是逻辑上的数据结构，后面是物理上的数据结构。堆的数据结构是一个完全二叉树，如果二叉树每一层的节点都是满的称为满二叉树，除开最后一层其它层都是满称为完全二叉树。 堆中又分为小顶堆和大顶堆，小顶堆就是顶部元素是二叉树节点中最小的，大顶堆就是顶部元素是所有节点中最大的。 我们直到满二叉树是个等比数列，虽然堆的数据结构是完全二叉树，但是也是适用等比数列的性质，为了快速定位到某个节点的父节点，index/2就是父节点的索引，在用数组存储数据的时候会
优先级队列-堆数据结构
m0_52083255的博客
11-10 757
优先级队列（堆）优先级队列（ PriorityQueue）优先级队列的概念优先级队列的使用1. 三种构造方式2. 常见方法3. 使用时的注意事项优先级队列的模拟实现---->堆堆的概念堆的性质堆的顺序存储堆的创建Top-k问题 优先级队列（ PriorityQueue） 优先级队列的概念 我们知道队列是先进先出的结构，而优先级队列则是指元素进出顺序是有先后次序的，在出队列时，可能需要优先级高或者优先级低的元素先出队列，这种数据结构就称为优先级队列；该结构是线程不安全的； 类似于医院，银行，机场或者其
数据结构——优先级队列(堆)
qq_62274623的博客
07-17 1864
优先级队列(堆)超详细解答，速看！
Java数组模拟优先级队列数据结构的实例
09-02
优先级队列是一种特殊的数据结构，它按照元素的优先级进行组织。在优先级队列中，具有较高优先级的元素会被优先处理。在Java中，实现优先级队列通常会利用内置的数据结构如`TreeSet`或`TreeMap`，因为它们提供了自动...
优先级队列（堆实现）
08-08
在Java中，优先级队列是通过`java.util.PriorityQueue`类来实现的，它基于一个二叉堆（Binary Heap）的数据结构。本文将深入探讨优先级队列的概念、实现方式以及如何在实际编程中使用。 首先，理解二叉堆是理解...
数据与算法：2基本数据结构7-优先级队列.pdf
06-26
优先级队列的实现方式有多种，可以基于有序顺序表、无序顺序表、有序链表、无序链表、堆等数据结构。 在优先级队列中，每个元素都有一个优先权值，优先权值越高的元素越先被取出。例如，在任务队列中，每个任务都有...
配置Java开发环境
Broken_x的博客
07-10 1523
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 495
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Spring Security 授权
persistence_PSH的博客
07-14 674
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 605
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
elk部署springboot
Chihirozy的博客
07-11 333
elk部署springboot。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 274
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
从零手写实现 nginx-27-return 指令
最新发布
07-14 386
大家好，我是老马。很高兴遇到你。我们为 java 开发者实现了 java 版本的 nginx如果你想知道 servlet 如何处理的，可以参考我的另一个项目：手写从零实现简易版 tomcatminicat。
JavaSE 面向对象程序设计进阶 IO流 字节流详解 抛出异常
牛马程序员的博客
07-10 776
存储和读取数据的解决方案内存中数据不能永久化存储 程序停止运行 数据消失File只能对文件本身进行操作 不能读写文件里存储的数据读写数据必须要有IO流可以把程序中的数据保存到文件当中还可以把本地文件中的数据读取到数据当中。
秋招Java后端开发冲刺——MyBatisPlus总结
qq_50604294的博客
07-13 488
本文对MyBatisPlus进行了介绍，并对其特点、基本使用和扩展功能进行了总结概括。
优先级队列的数据结构发一下
06-09
优先级队列的数据结构可以用堆（Heap）或者平衡树（如红黑树）来实现，这里分别给出两种常见的实现方式。 1. 堆实现优先级队列 堆是一种完全二叉树，可以用数组来实现。在堆中，每个节点的值都大于等于（或小于等于）其子节点的值，称为最大堆或最小堆。可以使用最大堆实现升序优先级队列，使用最小堆实现降序优先级队列。 优先级队列基本操作： - 插入元素：将新元素插入到堆的最后一个位置，并将其与其父节点比较，若其优先级高于其父节点，则交换位置，直到满足堆的性质为止。 - 取出元素：将堆的根节点取出，并将堆的最后一个元素放到根节点，再将其与其子节点比较，若其优先级低于其子节点，则交换位置，直到满足堆的性质为止。 - 查看堆顶元素：返回堆的根节点。 2. 平衡树实现优先级队列 平衡树是一种自平衡的二叉查找树，常用的有红黑树、AVL树等。使用平衡树实现优先级队列时，可以将元素的优先级作为键值进行排序。 优先级队列基本操作： - 插入元素：将新元素插入到平衡树中，根据键值进行排序。 - 取出元素：查找平衡树中最高（或最低）优先级的元素，并将其删除。 - 查看队列头元素：查找平衡树中最高（或最低）优先级的元素，但不删除。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值