堆和优先级队列

已于 2022-03-22 17:15:47 修改
阅读量1.4k 收藏 1
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 java 算法
于 2022-03-22 13:42:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58652786/article/details/123637053
版权

【前言】堆有很多种存储方式，二叉堆是其中一种，下面我们所说的堆均默认为二叉堆，即基于二叉树的堆

目录

1.堆

1.1堆的特点

1.2堆的内部存储实现

1.3自己实现一个最大堆

1.4堆排序 

 2.优先级队列

2.1何为优先级队列

2.2自定义优先级

2.3优先级队列的实现

2.4JDK中的优先级队列

 2.5TopK问题

3.小结

1.堆

1.1堆的特点

  • 首先堆在逻辑上是一棵完全二叉树
  • 其次，一般物理上用顺序表（数组）来存储
  • 根据堆节点间大小关系的不同，堆又分为大根堆和小根堆两种

大根堆：也叫最大堆，堆中根节点值一定>=子树节点值

小根堆：也叫最小堆，堆中根节点值一定<=子树节点值

【注意】节点的大小关系与所处层次无关，不能肯定的说低层次的节点值一定比高层次的节点值大或小。如下图，是一个小根堆，满足任意一个根节点都比子树节点小，但是，第二层的右节点值56可以比第三层的不同子树的节点值25大

1.2堆的内部存储实现

因为堆逻辑上是一棵二叉树，所以通常我们都用顺序表（也就是数组）来存储，原因有以下两点：

（1）完全二叉树，用顺序表存储，并不会导致诸如空节点等存储空间浪费的问题

（2）依据二叉树的节点编号规律，我们可以根据节点编号快速访问到某节点的父节点或子节点，而顺序表的索引就可以很好的实现这一点，索引下标相当于二叉树的节点编号，直接根据索引快速访问到父节点和左右子节点

【注意】对于不是完全二叉树的其他树，则一般不建议使用数组存储，因为会有空间的浪费

1.3自己实现一个最大堆

（ps:该最大堆是基于整型的，顺序表存储的，Java实现的最大堆）

（1）内部变量 和 构造函数

public class My_Max_Heap {
    List<Integer> data;

    //    无参构造
    public My_Max_Heap() {
        data = new ArrayList<>(100);
    }

    //    有参构造
    public My_Max_Heap(int size) {
//        顺序表存储，既无空间浪费又便于找父、左右子节点的索引位置
        data = new ArrayList<>(size);
    }
}

（2）查找左右子节点、父节点（该实现方法节点编号从0开始）

（返回左右子节点、父节点的索引下标）

    /**
     * 根据子节点找父节点
     *
     * @param k 子节点索引下标
     * @return 父节点索引下标
     */
    public int parent(int k) {
        return (k - 1) >> 1;
    }

    //    找左节点索引
    public int leftChild(int k) {
        return (k << 1) + 1;
    }

    //    找右节点索引
    public int rightChild(int k) {
        return (k << 1) + 2;
    }

（3）判空及输出函数

    //    判空
    public boolean isEmpty() {
        return data.isEmpty();
    }

    //    输出
    public String toString() {
        return data.toString();
    }

（4）向最大堆中添加元素 add(val)方法

思路：

  • 先将该元素添加到数组末尾，即二叉树最后一个元素
  • 然后从该元素开始进行元素的上浮操作

上浮操作是堆这里很重要的一个操作，那么，怎么上浮呢？

节点如果比父节点值大，说明不满足大根堆，交换该结点与父节点的位置，交换过后接着继续和上一级父节点比较，直至满足大根堆要求

代码实现：


    /**
     * 在最大堆中在合适位置插入元素，使其仍然为最大堆
     *
     * @param val 待插入的元素值
     */
    public void add(int val) {
//        在数组最后添加元素
        data.add(val);
//        然后进行上浮操作
        siftUp(data.size() - 1);
    }


    /*
    节点的上浮操作
     */
    private void siftUp(int k) {
//        当未走到根节点并且父节点小于该节点时，交换与根节点的位置
        while (k > 0 && data.get(parent(k)) < data.get(k)) {
            swap(parent(k), k);
            k = parent(k);
        }
    }
    //    交换
    private void swap(int i, int j) {
        int temp = data.get(i);
        data.set(i, data.get(j));
        data.set(j, temp);
    }

 （5）查询最大堆中的最大元素

最大元素即为根节点，即为顺序表的第一个元素，直接返回索引下标为0的元素即可（注意判空）

    /**
     * 查询最大的元素
     *
     * @return 返回最大的元素
     */
    public int peek() {
        if (isEmpty()) {
            throw new NoSuchElementException("heap is null!!!can not peek");
        }
        return data.get(0);
    }

（6）取出最大堆中的最大元素

【注】不断取出最大堆的最大元素，得到数据的降序排序

即返回最大值并删除该结点，关键是如何删除

删除根节点，并且要使删除后的堆仍为最大堆，如何实现呢？

  • 先将数组末尾元素移至首位，即将最后一个元素移动为根节点
  • 然后，从根节点开始进行下沉操作 

下沉操作：（同上浮操作类似）

对于最大堆而言，先确定左右子节点中的最大值，然后判断根节点是否比这个最大值大，如果是，则满足最大堆，否则，根节点小于子节点，需将根节点与这个最大值交换，交换后继续比较，直至走到叶子节点或找到正确位置

代码实现：

    /**
     * 取出最大堆中最大的那个元素（保持取出后仍为最大堆）
     */
    public int extractMax() {
//        凡是取值都要注意判空
        if (isEmpty()) {
            throw new NoSuchElementException("heap is null!!!can not extractMax");
        }
        int a = data.get(0);
//        先将最后一个元素移至首位根，再从首位根开始进行元素下沉操作，通过下沉使依然保持大根堆
        int b = data.get(data.size() - 1);
        data.set(0, b);
        data.remove(data.size() - 1);
        siftDown(0);
        return a;
    }


    /*
    节点的下沉操作
     */
    public void siftDown(int k) {
//        当还未走到叶子节点
        while (leftChild(k) < data.size()) {
            int j = leftChild(k);
//            判断是否有右子树，选左、右子树中大的那个下沉
            if ((j + 1) < data.size() && data.get(j + 1) > data.get(j)) {
                j = j + 1;
            }
//            此时j是左右子树中大的那个
//            如果当前元素小于左右子树中大的那个，则二者交换，否则break
            if (data.get(k) < data.get(j)) {
                swap(k, j);
                k = j;
            } else {
                break;
            }
        }
    }
    //    交换
    private void swap(int i, int j) {
        int temp = data.get(i);
        data.set(i, data.get(j));
        data.set(j, temp);
    }

（7）建堆（即将任意数据堆化）

两种方法：

一种方法是将数据不断进行堆的add操作，当数据较多时，不易操作；

第二种方法：

任意一个数组逻辑上都可以看作是一棵完全二叉树，只是可能还不太满足堆的特性，为此，我们需要调整内部元素的排列顺序，使其逻辑上是最大堆或最小堆。

以最大堆为例，调整顺序时，我们只需要从完全二叉树的最后一个非叶子节点开始对每个结点进行下沉操作，即可得到最大堆

以数组【1,5,3,8,7,6】为例，该数组默认的完全二叉树如下图：

从最后一个非叶子结点3开始进行下沉操作： 

细节：最后一个非叶子结点即为最后一个元素的父节点

代码实现：

//    本方法是从最后一个非叶子节点开始进行下沉操作
    public My_Max_Heap(int[] arr) {
//        先将长度复制过来
        data = new ArrayList<>(arr.length);
        for (int a : arr) {
            data.add(a);
        }
//        从最后一个非叶子结点开始进行下沉操作
        for (int i = parent(data.size() - 1); i >= 0; i--) {
            siftDown(i);
        }
    }
    /*
    节点的下沉操作
     */
    public void siftDown(int k) {
//        当还未走到叶子节点
        while (leftChild(k) < data.size()) {
            int j = leftChild(k);
//            判断是否有右子树，选左、右子树中大的那个下沉
            if ((j + 1) < data.size() && data.get(j + 1) > data.get(j)) {
                j = j + 1;
            }
//            此时j是左右子树中大的那个
//            如果当前元素小于左右子树中大的那个，则二者交换，否则break
            if (data.get(k) < data.get(j)) {
                swap(k, j);
                k = j;
            } else {
                break;
            }
        }
    }

1.4堆排序 

排升序要建大堆；排降序要建小堆

默认排序为升序：

（1）先将给定的数组堆化（最大堆）

（2）堆化后堆顶元素即为最大值，最大值应该在最后一个位置，所以交换堆顶和最后一个元素的位置

（3）交换后，从堆顶元素开始进行下沉操作（下沉至未排序的位置，这里即倒数第二个位置），除最后一个元素外，又是一个大根堆，此时，再将堆顶元素和倒数第二个元素互换，然后再从堆顶开始进行下沉操作……

（4）重复二三步操作，直至已经全部排序完成

栗子：以【3，5，2，4，8】为例

依此类推，直至元素全部落在了正确位置 

【性能分析】堆排序的时间复杂度为O（n log n)，空间复杂度为O（1），是不稳定的排序

代码实现：

import java.util.Arrays;

//堆排
public class heap_Sort {
    public static void heapSort(int[] arr) {
//        先将数组arr堆化,从第一个非叶子节点开始下沉操作
        for (int i = (arr.length - 1 - 1) / 2; i >= 0; i--) {
            siftDown(arr, i, arr.length);
        }
//        此时已是最大堆
        for (int i = arr.length - 1; i > 0; i--) {
//            将最大的元素移至最后一个位置，次大的元素移至倒数第二个位置……
            swap(arr, 0, i);
//            每次换好一个位置后，将其余元素下沉重新堆化
            siftDown(arr, 0, i);
        }
    }

    //    交换
    private static void swap(int[] arr, int index1, int index2) {
        int temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }

    /**
     * 下沉操作（大根堆）
     *
     * @param arr
     * @param i      开始下沉的位置
     * @param length 下沉的长度
     */
    public 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]) {
                swap(arr, i, j);
                i = j;
            } else {
                break;
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {1,7,3,5,2};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

 输出结果：

[1, 2, 3, 5, 7]

 2.优先级队列

2.1何为优先级队列

首先，普通队列是基于链表实现的，遵循先进先出原则，而

  • 优先级队列则不再是遵循先进先出原则，而是优先级高的元素先出队
  • 优先级队列看起来是队列，实则底层是基于堆实现的（JDK中的优先级队列默认是基于最小堆实现的）
  • JDK中的优先级队列：PriorityQueue<>()，（基于小根堆实现）

优先级队列 VS 普通队列

普通队列优先级队列
内部实现基于链表基于堆
入队的时间复杂度O（1）O（log N)
最大元素出队的时间复杂度O（N）O（log N）

2.2自定义优先级

如果优先级队列中存储的是自定义的类，或者我们想要按照自己的希望定义优先级，则需要对优先级进行自定义

自定义方法有三种方法：

一：实现Comparable接口，覆写compareTo方法(java.lang.Comparable)

//方法一,实现Comparable接口
class Student implements Comparable<Student> {
    int age;
    String name;
    int sum;

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

    public int compareTo(Student o) {
        return this.age - o.age;
    }

    public String toString() {
        return this.name + " " + this.age + " " + this.sum;
    }
}

二：有时候我们希望是升序有时候又希望是降序，所以，还有另一种方法，新建类,实现Comparartor接口,作为比较器（java.util.Comparator)

    public static void main(String[] args) {
//        方法二的使用
//        使用升序比较器
        Queue<Student> q2 = new PriorityQueue<>(new StudentAgeOn());
        q2.offer(new Student(2, "a", 100));
        q2.offer(new Student(8, "g", 88));
        q2.offer(new Student(100, "x", 1));
        System.out.println(q2.poll());
        
//        使用降序比较器
        Queue<Student> q3 = new PriorityQueue<>(new StudentAgeDown());
        q3.offer(new Student(2, "a", 100));
        q3.offer(new Student(8, "g", 88));
        q3.offer(new Student(100, "x", 1));
        System.out.println(q3.poll());

}
//方法二,新建类,实现Comparartor接口,作为比较器
//StudentOn -按年龄大小顺序
class StudentAgeOn implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}

//StudentDown - 按年龄大小倒序
class StudentAgeDown implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o2.age - o1.age;
    }
}

三：最后一种是函数式编程方法，如下：

Queue<Student> mypri1 = new PriorityQueue<>(((o1, o2) -> o1.age - o2.age));

2.3优先级队列的实现

基于上面自己实现的大根堆，我们继续实现优先级队列


/**
 * 基于大根堆实现的优先级队列【注意：JDK中的优先级队列默认是基于小根堆实现】
 */
public class My_PriorityQueue_Heap {
    My_Max_Heap priorityQueue;

    //    无参构造
    public My_PriorityQueue_Heap() {
        priorityQueue = new My_Max_Heap();
    }

    //    入队
    public void offer(Integer val) {
        priorityQueue.add(val);
    }

    //    队首元素
    public Integer peek() {
        return priorityQueue.peek();
    }

    //    出队
    public Integer poll() {
        return priorityQueue.extractMax();
    }

    //    判空
    public boolean isEmpty() {
        return priorityQueue.isEmpty();
    }
//
    public String toString(){
        return priorityQueue.toString();
    }

}

2.4JDK中的优先级队列

PriorityQueue implements Queue

 2.5TopK问题

优先级队列的一个典型应用就是Top K问题

那么什么是Top K问题呢，通俗点说就是找前k个元素，可以是前K个最大的也可以是前k个最小的

前提核心是：

取大用小（取前k个最大的，则建小根堆）

取小用大（取前k个最小的，建立大根堆）

用优先级队列解，时间复杂度仅为O（n log k)， 而正常排序的做法，时间复杂度最好也为

O（n long n)，k必然是<=n，所以，用优先级队列解是最好的

优先级队列解TopK（以取前3个最大元素为例）：

底层思路：

（1）建一个长度为3的优先级队列（最小堆）

（2）先按顺序入队，队入满

（3）再入第四个元素时，开始与根节点打擂

  • 因为根节点是优先级队列中最小的，如果第四个元素小于根结点，说明这第四个元素小于优先级队列里的3个元素，说明这第四个元素肯定不在前三元素里，直接continue
  • 如果第四个元素比根节点值大，则将根节点出队，让第四个元素入队

（4）重复第三步操作，直至遍历完数据

更为简单的理解：

先不断入队，当对内元素大于k时，出队

伪代码：

//        取前k个
        for(Map.Entry<Integer,Integer> entry: map.entrySet()) {

// 先入队
            priorityQueue.add(new Freg(entry.getKey(),entry.getValue()));

//当大于k时，出队
            if(priorityQueue.size() > k){
                priorityQueue.poll();
            }
        }

实战演练：

（1）347. 前 K 个高频元素 - 力扣（LeetCode） (leetcode-cn.com)

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

【细节】

按出现频率，所以我们要用map存储元素及其出现次数；

使用优先级队列要重定义优先级，可以借助辅助类，新定义一个类，类中变量即为元素及出现次数，覆写compareTo方法

题解：

class Solution {
    //借助自定义类来存储元素及其出现次数，并实现Comparable接口
    class Freg implements Comparable<Freg>{
        private int num;
        private int times;
        public Freg(int num,int times){
            this.num = num;
            this.times = times;
        }

        @Override
        public int compareTo(Freg o) {
            return this.times - o.times;
        }
    }
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer, Integer> map = new HashMap<>();
//        将每个数组元素及其对应频数存储到map表中
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(nums[i])) {
                map.put(nums[i], map.get(nums[i]) + 1);
            } else {
                map.put(nums[i], 1);
            }
        }
//        然后使用优先级队列，取前k个
        Queue<Freg> priorityQueue = new PriorityQueue<>();
//        取前k个
        for(Map.Entry<Integer,Integer> entry: map.entrySet()) {
            priorityQueue.add(new Freg(entry.getKey(),entry.getValue()));
            if(priorityQueue.size() > k){
                priorityQueue.poll();
            }
        }
     
        int[] res = new int[k];
        for (int i = 0; i < k; i++) {
            res[i] = priorityQueue.poll().num;
        }
        return res;
    }
}

 其他TopK问题还有：

面试题 17.14. 最小K个数 - 力扣（LeetCode） (leetcode-cn.com)

373. 查找和最小的 K 对数字 - 力扣（LeetCode） (leetcode-cn.com)

692. 前K个高频单词 - 力扣（LeetCode） (leetcode-cn.com)

165. 比较版本号 - 力扣（LeetCode） (leetcode-cn.com)

3.小结

关于堆以及优先级队列，重点应掌握以下内容：

（1）最大堆最小堆的实现（重点是堆的上浮、下沉操作）

（2）掌握堆排序

（3）灵活运用优先级队列解决问题，灵活变通定义优先级（三种方法：实现Collection接口覆写compareTo方法、自定义比较器类、函数式编程）

（4）能够用优先级队列解决TopK问题

笨笨在努力
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
【数据结构】堆与优先级队列
qq_48479056的博客
04-03 168
但是在有些情况下，操作的数据可能带有优先级，那么出队列时，就需要优先级高的元素先出队列。思想：我们可以认为最后的叶子节点每个都满足最大堆的要求(因为左右子树都是null)， 那从不断的从最后一个不是叶子节点的 节点让它满足最大堆，也就是元素下沉，使得每个子树为堆。最大堆：堆中的某个节点的值总是不大于其父节点的值，堆顶保存的是最大值；最小堆：堆中的某个节点的值总是不大于其父节点的值，堆顶保存的是最小值。同样的，根据堆的性质，通过给定的节点编号k，我们可以获取父节点，左孩子和右孩子的编号。
【数据结构-JAVA】堆和优先级队列
qq_41233305的博客
02-01 610
【数据结构-JAVA】堆以及优先级队列
堆 和 优先级队列
最新发布
Fighting！！！
04-10 924
堆、优先级队列、实现一个优先级队列、PriorityQueue的应用
堆(heap)与优先队列（priority queue）
weixin_52575498的博客
03-25 3602
一、堆 1.堆定义： 如果这棵完全二叉树的任意结点的关键字小于或等于其左孩子和右孩子的关键字，则称之为小堆
优先级队列（PriorityQueue）和堆
weixin_63189874的博客
05-31 1404
前面介绍过队列，是一种先进先出(FIFO)的数据结构，但有些情况下，操作的数据可能带有，一般出队列时，可能需要优先级高的元素先出队列，该中场景下，使用队列显然不合适，比如：在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话；初中那会班主任排座位时可能会让成绩好的同学先挑座位。在这种情况下，数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是。
认识优先级队列与堆
weixin_47651920的博客
11-14 1379
目录 一.什么是优先级队列 二.优先级队列的使用 1.使用优先级队列时的注意事项 3.优先队列的创建与使用 （1）构造方法 （2）常用方法 （3）优先级队列的使用 三.堆的学习与使用 1.引入 2.堆的概念 2.堆的性质 3.堆的示意图 4.堆的存储方式 5.堆的创建方式（这里我们以小堆来进行举例） （1）向下调整法 （2）向下调整的代码实现 4.使用向下调整法创建堆 （1）堆的思路示意图 （2）建堆过程 （3）代码实现 5.堆的插入与删除思...
heapq:PythonJavaScript堆和优先级队列库
05-13
PythonJavaScript堆和优先级队列库。 父级是和 。 let { heapify , heappop , heappush , heappushpop , heapreplace , merge , nlargest , nsmallest , } = heapq ; 参考 Python的heapq库。
Python实现一个优先级队列的方法
09-16
优先级队列是一种特殊的数据结构，它按照元素的优先级进行排序，最高优先级的元素总是在队列的前端。在Python中，可以利用内置的`heapq`模块来实现优先级队列。本文将详细介绍如何使用Python创建一个优先级队列，并...
优先级队列（堆实现）
08-08
NULL 博文链接：https://java--hhf.iteye.com/blog/2163480
c语言实现优先级队列
05-27
用c语言实现的，简单易懂，希望对大家有用。
prioqueue：ES6的优先级队列
02-05
优先队列 ES6的优先级队列 描述 ES6实现具有TypeScript支持的... 为了提高性能，Prioqueue优先级队列使用数组实现的二进制堆作为其骨干，从而为插入和删除提供O(log n)性能。 用法 Prioqueue公开了可链接的API，可
优先级队列和堆
yahid的博客
06-21 978
优先级队列:返回最高优先级对象、添加新的对象 堆:将一个给定的集合或数组里面的元素按照完全二叉树层序遍历的顺序存储在一个一维数组中 堆的存储方式:大根堆、小根堆 大根堆:每个节点都大于左右子节点 小根堆:每个节点都小于左右子节点 模拟实现优先级队列(堆)的创建: 思路:堆的向下调整 1.从最后一科子树开始调整 2.每颗子树调整的时候都是向下调整 主要解决问题: (1)确定最后一课子树的根节点p = [(len-1)-1]/2 (2)p-- (3)堆向下调整，确保左右子节点<l.
【堆和优先级队列】
Word码鸭的博客
03-29 6475
二叉堆 堆的代码实现 最大堆代码实现 向最大堆中添加一个元素—siftUp操作 删除堆顶元素—siftDown操作 测试代码方法 heapify 堆化 优先级队列 自定义类型的优先级队列实现 Comparator接口——比较器
JAVA 堆 与 优先级队列 关系
yiqqYi的博客
02-28 209
一 ： 堆 什么是堆？ 堆可以理解成一个完全二叉树 只不过堆是以数组的形式表现出来的 满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆4. 反之，则是小堆，或者小根堆，或者最小堆。 大堆与小堆可以用于筛选数组之中最大值或是最小值， 比如在千万级别的数据中找到前五个最大的值，那么就要建立一个有五个元素的小堆，每一次筛选，如果筛选的元素比堆顶就找到堆顶最小的元素将其换下来 那...
堆和优先队列
universe_ant的博客
12-09 587
0、引言 在许多问题中，当对数据集进行频繁的插入和删除操作时，往往需要快速确定最大或最小的元素。处理这种问题的方法之一，就是使用一个已排好序的数据集。通过这种方法，最大或最小元素总是处在数据集的头部(这取决于使用升序还是降序排列)。然而，将数据集一遍又一遍地进行排序的代价是非常高的。并且很多情况下，将元素排序并不是操作的目的，最终我们可能在真正要做的工作之外做了很多其他的工作。想要快速地找到最大
数据结构——优先队列与堆
lfm1010123的博客
06-13 928
优先级队列的底层实际上就是利用堆这种数据结构实现的。堆在逻辑上是一颗完全二叉树，而其物理结构却是数组，二叉树中的每个节点对应着数组的下标，树中的第一个节点（根节点）的数组下标为0，树中的最后一个节点不一定为数组的最后一个元素（数组可能没满），而我们学习的堆，分为两种：① 大顶堆：每个节点的值都 >= 其左右孩子节点的值，此外，第一个根节点的值一定是所有堆中其余节点的最大值。 ② 小顶堆：每个节点的值都 .........
优先队列和堆
数据工匠记
08-03 968
什么是优先队列？ 听这个名字就能知道，优先队列也是一种队列，只不过不同的是，优先队列的出队顺序是按照优先级来的；在有些情况下，可能需要找到元素集合中的最小或者最大元素，可以利用优先队列ADT（Abstract Data Type）来完成操作，优先队列ADT是一种数据结构，它支持插入和删除最小值操作（返回并删除最小元素）或删除最大值操作（返回并删除最大元素）； 这些操作等价于队列的enQueue和deQueue操作，区别在于，对于优先队列，元素进入队列的顺序可能与其被操作的顺序不同，作业调度是优先队列的一个应
【数据结构笔记15】优先队列、堆、最大堆、堆的操作（插入、删除、建立）与C实现
记录学习痕迹的公众号：Piper蛋窝
09-27 991
由优先队列概念引出堆的概念，堆的删除中提到“向下过滤”思想。
java优先级队列最小堆
10-19
Java中的优先级队列可以使用最小堆来实现。 最小堆是一种二叉树，其中每个父节点的值都小于或等于其子节点的值。在Java中，可以使用PriorityQueue类来实现最小堆。PriorityQueue类提供了许多方法来操作最小堆，例如...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

笨笨在努力

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

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

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

打赏作者

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

抵扣说明：

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

余额充值