优先级队列(PriorityQueue)-java

最新推荐文章于 2024-06-22 09:02:14 发布
最新推荐文章于 2024-06-22 09:02:14 发布
阅读量157 收藏 1
点赞数 1
文章标签： 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65846395/article/details/133997092
版权

一.优先级队列的介绍

1.概念

队列是一种先进先出(FIFO)的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列，该中场景下，使用队列显然不合适，比如：在手机上玩游戏的时候，如
果有来电，那么系统应该优先处理打进来的电话；初中那会班主任排座位时可能会让成绩好的同学先挑座位。
在这种情况下，数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构叫做优先级队列（priorityQueue）

2.优先级队列模拟实现

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

二.堆的介绍

1.堆的概念

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

2.堆的性质：

堆中某个节点的值总是不大于或不小于其父节点的值。堆总是一颗完全二叉树。
在这里插入图片描述
在这里插入图片描述

3.堆的存储方式

从堆的概念可知，堆是一棵完全二叉树，因此可以层序的规则采用顺序的方式来高效存储，对于非完全二叉树，则不适合使用顺序方式进行存储，因为为了能够还原二叉树，空间中必须要存储空节
点，就会导致空间利用率比较低。
将元素存储到数组中后，可以根据二叉树章节的性质5对树进行还原。假设i为节点在数组中的下标，则有：
如果i为0，则i表示的节点为根节点，否则i节点的双亲节点为 (i - 1)/2
如果2 * i + 1 小于节点个数，则节点i的左孩子下标为2 * i + 1，否则没有左孩子
如果2 * i + 2 小于节点个数，则节点i的右孩子下标为2 * i + 2，否则没有右孩子

4.堆的创建与向下调整

对于集合{ 27,15,19,18,28,34,65,49,25,37 }中的数据，如果将其创建成堆呢？
在这里插入图片描述
向下过程(以小堆为例)：

  1. 让parent标记需要调整的节点，child标记parent的左孩子(注意：parent如果有孩子一定先是有左孩子)
  2. 如果parent的左孩子存在，即:child < size， 进行以下操作，直到parent的左孩子不存在
  3. parent右孩子是否存在，存在找到左右孩子中最小的孩子
    将parent与较小的孩子child比较，如果：
    parent小于较小的孩子child，调整结束
    否则：交换parent与较小的孩子child，交换完成之后，parent中大的元素向下移动，可能导致子树不满足对的性质，因此需要继续向下调整，即parent = child；child = parent*2+1; 然后继续2操作。
    先创建一个数组用来存堆元素:
class MyTree{
    public int[] elum;
    public int unsized;
    public static final  int CAPA_City=20;
    public MyTree() {
        this.elum = new int[CAPA_City];
    }
    public void create(int[] arry){
        for(int i=0;i<arry.length;i++){
            if(unsized==CAPA_City){
                elum= Arrays.copyOf(elum,2*elum.length);
            }
            elum[i]=arry[i];
            unsized++;
        }
        }

接着向下调整：

 for(int parent = (unsized-1)/2;parent>=0;parent--){
            shiftdown(parent,unsized);
        }

    }
    public void shiftdown(int parent,int len){
        int child = 2*parent+1;
        while(child<len){
            if(child+1<len&&child<child+1){
                child = child+1;
            }
            if(elum[child]>elum[parent]){
                int tmp = elum[child];
                elum[child]=elum[parent];
                elum[parent]=tmp;
                parent = child;
                child=2*parent+1;
            }
            else{
                break;
            }

        }
    }

在这里插入图片描述

注意：在调整以parent为根的二叉树时，必须要满足parent的左子树和右子树已经是堆了才可以向下调整。最坏的情况即图示的情况，从根一路比较到叶子，比较的次数为完全二叉树的高度，即时间复杂度为log2n。

5.堆的插入和删除

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

  1. 先将元素放入到底层空间中(注意：空间不够时需要扩容)
  2. 将最后新插入的节点向上调整，直到满足堆的性质
    在这里插入图片描述
 public void push(int val){
        elum[unsized]=val;
        val++;
        shiftpush((unsized-1)/2);
    }
    public void shiftpush(int parent){
        int child=2*parent+1;
        while(child>0){
            if(elum[child]>elum[parent]){
                int tmp = elum[child];
                elum[child]=elum[parent];
                elum[parent]=tmp;
                child=parent;
                parent=(child-1)/2;
            }else{
                break;
            }
        }
    }

堆的删除
注意：堆的删除一定删除的是堆顶元素。具体如下：
3. 将堆顶元素对堆中最后一个元素交换
4. 将堆中有效数据个数减少一个
5. 对堆顶元素进行向下调整
在这里插入图片描述

public void del(){
        int tmp=elum[unsized-1];
        elum[unsized-1]=elum[0];
        elum[0]=tmp;
        unsized--;
        shiftdown(0,unsized);
   }

1.将堆顶元素和最后一个元素交换，
2.删除最后一个元素。
3.向下调整直到满足堆特征。

6.总代码

class MyTree{
    public int[] elum;
    public int unsized;
    public static final  int CAPA_City=20;
    public MyTree() {
        this.elum = new int[CAPA_City];
    }
    public void create(int[] arry){
        for(int i=0;i<arry.length;i++){
            if(unsized==CAPA_City){
                elum= Arrays.copyOf(elum,2*elum.length);
            }
            elum[i]=arry[i];
            unsized++;
        }
        for(int parent = (unsized-1)/2;parent>=0;parent--){
            shiftdown(parent,unsized);
        }

    }
    public void shiftdown(int parent,int len){
        int child = 2*parent+1;
        while(child<len){
            if(child+1<len&&child<child+1){
                child = child+1;
            }
            if(elum[child]>elum[parent]){
                int tmp = elum[child];
                elum[child]=elum[parent];
                elum[parent]=tmp;
                parent = child;
                child=2*parent+1;
            }
            else{
                break;
            }

        }
    }
    public void draw(){
        for(int i=0;i<unsized;i++){
            System.out.println(elum[i]);
        }
    }
    public void push(int val){
        elum[unsized]=val;
        val++;
        shiftpush((unsized-1)/2);
    }
    public void shiftpush(int parent){
        int child=2*parent+1;
        while(child>0){
            if(elum[child]>elum[parent]){
                int tmp = elum[child];
                elum[child]=elum[parent];
                elum[parent]=tmp;
                child=parent;
                parent=(child-1)/2;
            }else{
                break;
            }
        }
    }
   public void del(){
        int tmp=elum[unsized-1];
        elum[unsized-1]=elum[0];
        elum[0]=tmp;
        unsized--;
        shiftdown(0,unsized);
   }
}
public class Test1 {
    public static void main(String[] args) {
        MyTree myTree= new MyTree();
        int[] arry={23,11,45,2,15,14,36};
        myTree.create(arry);
        myTree.draw();
        System.out.println("************");
        myTree.push(3);
        myTree.draw();
    }
}

三.PriorityQueue的特性

1.priorityQueue的分类

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

2. priorityQueue的源码分析

1.对数组的初始化

在这里插入图片描述
要想看明白类的功能首先得看他的构造方法。
在这里插入图片描述
这是一个没有参数的构造方法，把数组容量和比较器传入了带2个参数的构造方法，我们继续观察带2个参数的构造方法!
在这里插入图片描述

如果传入的第一个参数的大小小于1抛异常，如果大于1让数组的大小等于该值。这里也是定义了数组的大小
总结:priorityDeque底层会自动开辟数组大小为11的内存空间。

2.增加元素offer方法

在这里插入图片描述
当第一次调用offer方法时候如果传入的值是空值则抛出异常，不是空值把数组第一个元素赋值为该值。
在这里插入图片描述
第二次调用offer的时候,i的值变为1，调用sifup方法，把i和e传过去，继续观察shiftup方法
在这里插入图片描述

因为comparator等于null,接着会调用siftupCompareable方法，点过去
在这里插入图片描述
在这里插入图片描述
当第二次调用offer方法把需要插入的值自动强制类型转换为可比较的类型，所以进行插入的值必须是可比较的，实验一下插入的值是不可比较的会怎么样

class Student{
    public int age;
    public String name;

    public Student(int age,String name) {
        this.age = age;
        this.name = name;
    }
}
public class Test2 {
    public static void main(String[] args) {
        Student student = new Student(1,"zzz");
        Student student1 = new Student(2,"dddd");
        PriorityQueue<Student> priorityQueue=new PriorityQueue<>();
        priorityQueue.offer(student);
    }
}

第一次调用offer方法代码正常运行，学生类没有实现比较器，正如上面的源码分析第一次调用offer方法并没有进行强制类型转换
在这里插入图片描述
我们继续调用offer方法
在这里插入图片描述

在这里插入图片描述

第二次调用的时候代码未正常通过，要想解决这个问题必须让该类型变为可比较的类型，实现comparable接口

class Student implements Comparable<Student>{
    public int age;
    public String name;

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


    public int compareTo(Student o) {
        return this.age-o.age;
    }
}
public class Test2 {
    public static void main(String[] args) {
        Student student = new Student(1,"zzz");
        Student student1 = new Student(2,"dddd");
        PriorityQueue<Student> priorityQueue=new PriorityQueue<>();
        priorityQueue.offer(student);
        priorityQueue.offer(student);
    }
}

在这里插入图片描述
comparable接口可以但效率不高，假如我要同时比较年龄和名字那么我要去修改compareto方法，这样做太麻烦，继续改进代码，让它实现comparator接口。

class Student implements Comparable<Student>{
    public int age;
    public String name;

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


    public int compareTo(Student o) {
        return this.age-o.age;
    }
}
class AgeCompare implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age-o2.age;
    }
}
class nameCompare implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}
public class Test2 {
    public static void main(String[] args) {
        Student student = new Student(1,"zzz");
        Student student1 = new Student(2,"dddd");
        PriorityQueue<Student> priorityQueue=new PriorityQueue<>();
        priorityQueue.offer(student);
        priorityQueue.offer(student);
    }
}

回看offer方法
在这里插入图片描述
该方法让最后一个有效元素的下一个下标放入想插入的值，然后向上调整堆。
总结：priorityQueue第一次调用offer方法不涉及比较函数，第二次调用必须插入的元素是可比较的。

3.删除元素poll方法

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

删除元素的本质其实是让堆顶元素和最后一个元素交换，然后删除最后一个元素，向下调整堆。
PriorityQueue默认是小根堆，试想如何让他变为大根堆。

   Student student = new Student(1,"zzz");
        Student student1 = new Student(2,"dddd");
        PriorityQueue<Student> priorityQueue=new PriorityQueue<>();
        priorityQueue.offer(student);
        priorityQueue.offer(student1);
        Student ret = priorityQueue.poll();
        System.out.println(ret.age);

在这里插入图片描述
priorityqueue可以传一个构造器过去，它的构造方法提供了该功能
在这里插入图片描述
当传入构造器要想变为大根堆只需要改比较函数的逻辑

class Student implements Comparable<Student>{
    public int age;
    public String name;

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


    public int compareTo(Student o) {
        return this.age-o.age;
    }
}
class AgeCompare implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o2.age-o1.age;
    }
}
class nameCompare implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}
public class Test2 {
    public static void main(String[] args) {
        Student student = new Student(1,"zzz");
        Student student1 = new Student(2,"dddd");
        AgeCompare ageCompare = new AgeCompare();
        PriorityQueue<Student> priorityQueue=new PriorityQueue<>(ageCompare);
        priorityQueue.offer(student);
        priorityQueue.offer(student1);
        Student ret = priorityQueue.poll();
        System.out.println(ret.age);
    }
}

在这里插入图片描述

4.扩容

在这里插入图片描述

如果容量小于64时，是按照oldCapacity的2倍方式扩容的
如果容量大于等于64，是按照oldCapacity的1.5倍方式扩容的
如果容量超过MAX_ARRAY_SIZE，按照MAX_ARRAY_SIZE来进行扩容

priorityqueue的应用

static void TestPriorityQueue(){
// 创建一个空的优先级队列，底层默认容量是11
PriorityQueue<Integer> q1 = new PriorityQueue<>();
// 创建一个空的优先级队列，底层的容量为initialCapacity
PriorityQueue<Integer> q2 = new PriorityQueue<>(100);
ArrayList<Integer> list = new ArrayList<>();
list.add(4);
list.add(3);
list.add(2);
list.add(1);
PriorityQueue<Integer> q3 = new PriorityQueue<>(list);
System.out.println(q3.size());
System.out.println(q3.peek());
// 用户自己定义的比较器：直接实现Comparator接口，然后重写该接口中的compare方法即可
class IntCmp implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
}
public class TestPriorityQueue {
public static void main(String[] args) {
PriorityQueue<Integer> p = new PriorityQueue<>(new IntCmp());
p.offer(4);
p.offer(3);
p.offer(2);
p.offer(1);
p.offer(5);
System.out.println(p.peek());
}

四.Topk问题

TOP-K问题：即求数据集合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都
不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：

  1. 用数据集合中前K个元素来建堆
    前k个最大的元素，则建小堆
    前k个最小的元素，则建大堆
  2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
    将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

问题：求数组中前k个最小元素

class IntegerCompare implements Comparator<Integer>{
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2-o1;
    }
}
public class Test3 {
    public static int[] findmin(int[] arr,int k){
        IntegerCompare integerCompare = new IntegerCompare();
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(integerCompare);
        for(int i=0;i<k;i++){
            priorityQueue.offer(arr[i]);
        }
        for(int i=k;i<arr.length;i++){
            int top = priorityQueue.peek();
            if(top>arr[i]){
                priorityQueue.poll();
                priorityQueue.offer(arr[i]);
            }
        }
        int[] arr1 = new int[k];
        for(int i=0;i<k;i++){
            arr1[i]=priorityQueue.poll();
        }
        return arr1;
    }

    public static void main(String[] args) {
        int[] arr ={12,34,45,65,1,87,3,64,4};
        findmin(arr,3);
    }
}

在这里插入图片描述

堆排序

让数组中的元素从小到大进行排序

class MyTree1 {
    public int[] elum;
    public int unsized;
    public static final int CAPA_City = 20;

    public MyTree1() {
        this.elum = new int[CAPA_City];
    }
    public void TreeSort(int[] arry){
        for(int i=0;i<arry.length;i++){
            elum[i]=arry[i];
            unsized++;
        }
        for(int parent = (unsized-1)/2;parent>=0;parent--){
            shiftdown(parent,unsized);
        }
        int cur = unsized-1;

        while(cur>0){
            int tmp = elum[0];
            elum[0]=elum[cur];
            elum[cur]=tmp;
            shiftdown(0,cur);
            cur--;
        }
    }
    public void shiftdown(int parent,int unsized){
        int child = 2* parent+1;
        while(child<unsized){
            if(child+1<unsized&&elum[child]<elum[child+1]){
                child=child+1;
            }
            if(elum[child]>elum[parent]){
                int tmp = elum[child];
                elum[child]=elum[parent];
                elum[parent]=tmp;
                parent=child;
                child=2*child+1;
            }else{
                break;
            }
        }
    }
    public void draw(){
        for(int i=0;i<unsized;i++){
            System.out.println(elum[i]);
        }
    }
}
public class Test4 {
    public static void main(String[] args) {
        MyTree1 myTree1=new MyTree1();
        int[] arry = {34,1,45,23,56,2,75};
        myTree1.TreeSort(arry);
        myTree1.draw();
    }
}

在这里插入图片描述

思考：可不可以建立小根堆，每次弹出最小的元素，弹出的元素大小就是有序的？
不可以，因为你并不是数组本身上有序的。
思路：先建立大小根堆，然后每次让最后一个元素和0下标元素进行交换，使其最后一个元素有序。

你的小10
关注
Java 集合框架：Java 中的优先级队列 PriorityQueue 的实现
栗筝i的博客
07-21 3040
在 Java 中是一种基于堆（Heap）数据结构实现的优先级队列。堆是一种特殊的完全二叉树，分为最小堆和最大堆。在最小堆中，每个节点的值都小于或等于其子节点的值；在最大堆中，每个节点的值都大于或等于其子节点的值。Java 的使用最小堆实现，因此队列头部总是优先级最高（值最小）的元素。
华为OD机试 - 支持优先级的队列 - 优先队列（Java 2023 B卷 100分）
学Java，找哪吒
06-03 2197
每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。
jdk优先级队列、延迟队列原理
小小少年的博客
04-17 603
优先级队列 PriorityQueue 这个类，是优先级队列的核心，包括我们下面要说的延迟队列，在jdk6之前，也是以这个为基础的 在该类中，维护了几个核心的属性 transient Object[] queue; // non-private to simplify nested class access private int size = 0; private final Comparator<? super E> comparator; 这里的queue，就是实际存放元素的数组结构
PriorityQueue ，ArrayList ， 数组排序
老李2009
07-27 1181
static class E implements Comparable<E>{ int x ; int y ; int state ; int money ; public E(int x
JDK源码剖析之PriorityQueue优先级队列
李哈zzz的博客
09-07 217
在数据结构中，队列分为FIFOLIFO两种模型，分别为先进先出，后进后出先进后出，后进先出（栈）而一切数据结构都是基于数组或者是链表实现。在Java中，定义了Queue接口，接口中定义了CRUD的基本方法。分别add、offer、remove、poll等等，而PriorityQueue 实现此接口实现了基本的CRUD的同时拥有了自己的特性，从名字来看也能知道是优先级队列 ： 保持队列头部节点是整条队列中永远是最小或者最大的节点，其实现原理就是一个小顶堆或者大顶堆。上文提及到。
PriorityQueue-数组（二叉堆）
csdn_ygy的博客
10-03 732
field //默认初始化大小 private static final int DEFAULT_INITIAL_CAPACITY = 11; //队列内置为数组，实际为数据结构中的二叉堆 transient Object[] queue; // non-private to simplify nested class access //容量大小
JDK8优先级队列/小根堆PriorityQueue源码分析及Top-K问题解决方案
开心的博客
12-08 570
目录1. 查看``PriorityQueue``2. 找到``new PriorityQueue``, 也就是初始化的时候代码3. 查看 this4. 如何建立小根堆4.1 offer分析4.1.1 队列扩容4.1.1.1 扩容实现4.1.1.2 考虑扩容溢出4.1.2 调整为小根堆4.2 poll分析 public class main { public static void main(String[] args) { PriorityQueue<Integer> m
Java中的优先级队列 PriorityQueue 与 堆
2301_76607156的博客
05-04 465
堆是一种完全二叉树，其中每个节点的值都不小于（或不大于）其子节点的值。最大堆(大根堆)：对于每个节点，其值都大于或等于其子节点的值。最小堆(小根堆)：对于每个节点，其值都小于或等于其子节点的值。
Java队列源码-priority-queue:Java中优先级队列实现的源代码
05-24
Java中的优先级队列（PriorityQueue）是一种特殊的队列，它按照元素的优先级进行排序。在Java集合框架中，PriorityQueue是位于java.util包下的一个类，它实现了Queue接口，但并不保证按照先进先出（FIFO）的顺序进行...
java的优先级队列PriorityQueue
qq_38748148的博客
12-30 739
介绍 Java中PriorityQueue通过二叉小顶堆实现，可以用一棵完全二叉树表示。 一个基于优先级堆的无界优先级队列。优先级队列的元素按照其自然顺序进行排序，或者根据构造队列时提供的 Comparator 进行排序，具体取决于所使用的构造方法。优先级队列不允许使用 null 元素。依靠自然顺序的优先级队列还不允许插入不可比较的对象（这样做可能导致 ClassCastException）。 构造方法： PriorityQueue() :使用默认的初始容量（11）创建一个优先级队列，并按其..
jdk优先级队列是如何实现的
小小少年的博客
03-20 325
在jdk中，自带了一个优先级队列，scheduledThreadPoolExecutor自己内部也实现了一个优先级队列 我们先不考虑jdk是如何实现的，其实让我们自己去实现一个优先级队列的实现的话，完全可以这样来做： 在入队的时候，根据当前key对应的hash值，或者是根据自己的特定的比较规则，从第一个元素开始对比，如果当前要入队的值小于队列中的第一个key，就插入到前面，反之，继续往后去对比，这样就可以实现一个简单的优先级队列，在每次取出来第一个元素的时候，就是优先级最高的 所以：对于优先级队列来说，最为
Java数据结构 - 优先级队列（PriorityQueue）
Jiali的博客
10-13 1326
JDK1.8中的PriorityQueue底层使用了堆的数据结构，那么我们先了解一下堆的概念。堆通常是一个可以被看做一棵二叉树的数组对象。堆中某个结点的值总是不大于或不小于其父结点的值；堆总是一颗完全二叉树。将根结点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。堆是非线性数据结构，相当于一维数组，有两个直接后继。堆的定义如下：n个元素的序列{k1, k2, k3, …, kn}当且仅当满足下关系时，称之为堆。
java堆和优先级队列PriorityQueue的使用及实现
丸啊~
03-03 1122
在谈优先级队列之前先简单说一下堆的概念。 堆(heap) 一、概念 1.堆在逻辑上是一棵完全二叉树 2.物理上是保存在数组中 3.满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆 4.反之，则是小堆，或者小根堆，或者最小堆 5.堆的基本作用是，快速找集合中的最值 二、大小根堆的建立向下调整实现 调整过程： 1.判断 index 位置有没有孩子 1)index 如果已经是叶子...
优先级队列简介
Hello,world!
01-08 664
优先级队列（PriprityQueue）是一种无界队列，基于优先级堆，它的元素根据自然顺序或者通过实现Comparator接口的自定义排序方式进行排序。这篇文章，我们将创建一个Items的优先级队列，基于价格排序，优先级队列用来实现迪科斯彻算法（Dijkstra algorithm）非常实用。值得注意的是他的迭代器并不保证有序，如果需要按顺序遍历，最好使用Arrays.sort(pd.toArra
数据结构——优先级队列(堆)Priority Queue详解
最新发布
Yuan_o_的博客
06-22 1532
优先级队列、堆模拟实现、存储方式、创建时间复杂度、插入和删除、堆常用接口、offer原理、PriorityQueue的扩容方式、top-k问题、堆排序
优先级队列的使用
iteye_13789的博客
08-23 115
自定义对象，并实现Comparable接口。使用代码如下： package tijava.container; import java.util.Collections; import java.util.PriorityQueue; import java.util.Queue; class ToDoItem implements Comparable&lt;ToDoItem&gt; {...
mysql 保留最新n条记录 删除其余记录
whatday的专栏
01-30 2933
在测试数据库时，想只保留最新的n条记录，删除剩余的记录，例如总计10条数据，只保留最新的5条数据，删除旧5条数据。 原数据记录为： 执行删除语句为： delete A from firedb A join (select id from firedb ORDER BY id limit 5) B on A.id<=B.id; 上述删除语句中是嵌套结构，其中 select id from firedb ORDER BY id limit 5 是从数据库中取前5条数据的id： .
【Java】PriorityQueue--优先级队列
热门推荐
weixin_73616913的博客
06-24 1万+
前面介绍过队列，队列是一种先进先出(FIFO)的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列，该中场景下，使用队列显然不合适，比如：在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话. 在这种情况下，数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue)。
优先级队列PriorityQueue详细解析
m0_64799333的博客
03-11 1896
优先级队列其背后就是一个堆，也就是完全二叉树，堆通常使用顺序表存储在做堆的题的时候，我们通常反着进行考虑。
JAVA PriorityQueue：无界优先级队列详解与实现
在Java编程中，`PriorityQueue` 是一个核心的并发容器，它属于 `java.util` 包下的一个类，专门设计用于实现无界优先级队列。`PriorityQueue<E>` 的类型参数 `E` 指定了队列中保存的元素类型。这个数据结构是基于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值