【Java】PriorityQueue优先级队列（堆）+比较器详解

最新推荐文章于 2024-08-26 18:51:14 发布
最新推荐文章于 2024-08-26 18:51:14 发布
阅读量3.3k 收藏 28
点赞数 28
分类专栏： 数据结构 文章标签： java 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/p_fly/article/details/127370748
版权

目录

铺垫

堆

建堆

基本公式

调整为大(小)根堆

堆的增加

堆的删除 

 正文：

比较

重写基类的equals()比较方法：

内部比较器——Comparable.compareTo(E o)：

外部比较器——Comparator.compare(T o1, T o2)：

源码粗略分析

常用构造方法

实现Comparable接口 

实现Comparator接口

改为大根堆

对于基本类型：

对于引用类型：

比较器快速写法

铺垫

堆

优先级队列的底层是一个数组，但这个数组又比较特殊——二叉树通过层序遍历存放到该数组的数据。这样存放的方式就是堆这种数据结构。

大根堆：如果在堆中，每个根结点的值大于两个孩子结点的值。（对左右孩子无要求）

小根堆：如果在堆中，每个根结点的值小于两个孩子结点的值。（对左右孩子无要求）

建堆

基本公式

调整为大(小)根堆

在一个一维数组中：

1.对于每一个根结点都要调整为大小根堆。

2.调整时，先要找到较大的孩子

3.然后二者交换，继续向下调整该根结点下面的结点。

4.调整时可能会存在越界的情况，孩子结点可能会越界。

    public void createHeap() {
        //建大根堆
        //对每一个根节点使用向下调整算法
        //最后一个孩子 c = length - 1
        //c = 2 * p +1
        //p = (c - 1)/2
        for (int parent = (array.length - 1 -1) / 2; parent >= 0; parent--) {
            shiftDown(parent, usedSize);
        }
    }
    //向下调整
    private void shiftDown(int parent, int length) {
        int child = 2 * parent + 1;
        while (child < length) {
               //先判断孩子是否越界
            if (child < length - 1 && array[child] < array[child + 1]) {
                child++;
            }
            if (array[parent] < array[child]) {
                swap(array, parent, child);
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }

    private void swap(int[] array, int x, int y) {
        int tmp = array[x];
        array[x] = array[y];
        array[y] = tmp;
    }

堆的增加

在堆里添加完数据后，应该还要保证堆为大(小)根堆。

1.判断堆是否满了，满了扩容。

2.把添加的数据放到数组的最后面。

3.找到最后一个结点的父亲结点，向上调整。

4.(建大堆)如果父亲结点比孩子结点小，就调整，然后，父亲结点指向孩子结点，重新计算父亲结点，直到最后一个孩子调整完。

5.useSized++

 

堆的删除 

优先级队列，是对于某些数据优先操作的结构，所以很自然的我们要优先对堆顶数据进行删除。

1.判断堆是否为空，为空抛出异常。

2.堆顶数据与最后一个结点进行交换。

3.对堆顶使用一次向下调整即可恢复成大(小)根堆。

4.useSized--

    public void pop() {
        if (isEmpty()) {
            return;
        }
        swap(array, 0, usedSize - 1);
        usedSize--;
        shiftDown(0, usedSize);
    }

 正文：

有了以上概念，我们就能更容易理解PriorityQueue的源码部分的实现。

比较

在生成大小根堆的时候，数据是通过比较大小来排序的。所以PriorityQueue底层必定有比较数据大小的东西。

重写基类的equals()比较方法：

所有的类都是继承Object类的，Object类中就有equals()方法。

重写equals()方法用到这里显然不合适，因为该方法只能比较二者是否想等，无法比较出大小关系。

内部比较器——Comparable<E>.compareTo(E o)：

Comparable是JDK提供的泛型接口类，源码如下：

//Compareble是java.lang中的接口类，可以直接使用
public interface Comparable<E> {
    // 返回值:
    // < 0: 表示 this 指向的对象小于形参 o 指向的对象
    // == 0: 表示 this 指向的对象等于形参 o 指向的对象
    // > 0: 表示 this 指向的对象大于形参 o 指向的对象
    int compareTo(E o);
}

//对象支持自己与自己比较
//实现了该接口的类就可以自动进行排序
//集合通过Collection.sort()排序，数组通过Arrays.sort()进行排序

该方法可以比较出数据的大小，所以我们可以在定义类的时候实现该接口，重写方法就可以比较。

外部比较器——Comparator<T>.compare(T o1, T o2)：

//Comparator是java.util 包中的泛型接口类，使用时必须导入对应的包

public interface Comparator<T> {
// 返回值:
// < 0: 表示 o1 指向的对象小于 o2 指向的对象
// == 0: 表示 o1 指向的对象等于 o2 指向的对象
// > 0: 表示 o1 指向的对象等于 o2 指向的对象
int compare(T o1, T o2);
}

//使用Comparator的情况：
//1.没有实现Comparable接口
//2.实现了Comparable接口，但是其中的compareTo方法不符合自己的预期

源码粗略分析

    public static void main(String[] args) {
        PriorityQueue<Integer>  priorityQueue1= new PriorityQueue<>();
        priorityQueue1.offer(4);
        priorityQueue1.offer(6);
        priorityQueue1.offer(3);
        System.out.println(priorityQueue1);
    }

 

若是其他引用类型，就不可以这样offer()了，在offer()第二个数据的时候就会抛异常。

class Student {
    public String name;
    public int age;

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

public class Test {
    public static void main(String[] args) {
        PriorityQueue<Integer>  priorityQueue1= new PriorityQueue<>();
        priorityQueue1.offer(4);
        priorityQueue1.offer(6);
        priorityQueue1.offer(3);
        System.out.println(priorityQueue1);

        PriorityQueue<Student>  priorityQueue2 = new PriorityQueue<>();
        priorityQueue2.offer(new Student(20));
        priorityQueue2.offer(new Student(22));
    }
}

常用构造方法

第一种：什么都不传，那么默认空间大小为11，无比较器

第二种：只传空间大小，此时空间大小为所传的值

第三种：只传比较器，下面详解比较器作用

实现Comparable接口 

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

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

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

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

public class Test {
    public static void main(String[] args) {
        PriorityQueue<Integer>  priorityQueue1= new PriorityQueue<>();
        priorityQueue1.offer(4);
        priorityQueue1.offer(6);
        priorityQueue1.offer(3);
        System.out.println(priorityQueue1);

        PriorityQueue<Student>  priorityQueue2 = new PriorityQueue<>();
        priorityQueue2.offer(new Student(20));
        priorityQueue2.offer(new Student(22));
        priorityQueue2.offer(new Student(23));
        System.out.println(priorityQueue2);
    }
}

 当实现了Comparable接口后，重写CompareTo方法后，此时就可以比较引用类型了。

此时它应该执行到一下源码部分。

实现Comparator接口

class Student {
    public String name;
    public int age;

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


    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class StuCompare implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o2.age - o1.age;
    }
}

public class Test {
    public static void main(String[] args) {
        PriorityQueue<Integer>  priorityQueue1= new PriorityQueue<>();
        priorityQueue1.offer(4);
        priorityQueue1.offer(6);
        priorityQueue1.offer(3);
        System.out.println(priorityQueue1);

        PriorityQueue<Student>  priorityQueue2 = new PriorityQueue<>(new StuCompare());
        priorityQueue2.offer(new Student(20));
        priorityQueue2.offer(new Student(22));
        priorityQueue2.offer(new Student(23));
        System.out.println(priorityQueue2);
    }
}

通过自定义的比较器，并且通过传入比较器的构造方法后，我们也可以比较。

此时它应该执行到下面的源码部分。

改为大根堆

因为源码默认建小根堆，如果我们想建大根堆，有了以上源码分析，我们不难发现，关键就在比较器上，我们只需要改变比较规则，就可以建立大根堆。

对于基本类型：

比如Integer，我们无法到源码中改变比较规则，所以只能传比较器，这样会优先使用有比较器的方法。

class IntCompare implements Comparator<Integer> {
    @Override
    public int compare (Integer o1, Integer o2) {
        return o2.compareTo(o1);
    }
}
public class Test {
    public static void main(String[] args) {
        PriorityQueue<Integer>  priorityQueue1= new PriorityQueue<>(new IntCompare());
        priorityQueue1.offer(4);
        priorityQueue1.offer(6);
        priorityQueue1.offer(3);
        System.out.println(priorityQueue1);
    }
}

 

对于引用类型：

若该引用类型实现了Comparable接口，我们直接修改compareTo

若没有，则修改比较器中的compare

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

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

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

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



public class Test {
    public static void main(String[] args) {
        PriorityQueue<Student>  priorityQueue2 = new PriorityQueue<>();
        priorityQueue2.offer(new Student(20));
        priorityQueue2.offer(new Student(22));
        priorityQueue2.offer(new Student(23));
        System.out.println(priorityQueue2);
    }
}

 ​​​​​

 

class Student {
    public String name;
    public int age;

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


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

class StuCompare implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o2.age - o1.age;
    }
}

public class Test {
    public static void main(String[] args) {
        PriorityQueue<Student>  priorityQueue2 = new PriorityQueue<>(new StuCompare());
        priorityQueue2.offer(new Student(20));
        priorityQueue2.offer(new Student(22));
        priorityQueue2.offer(new Student(23));
        System.out.println(priorityQueue2);
    }
}

比较器快速写法

class Student {
    public String name;
    public int age;

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

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

public class Test {
    public static void main(String[] args) {
        //这里直接new了一个比较器传过去了
        PriorityQueue<Student>  priorityQueue2 = new PriorityQueue<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.age - o2.age;
            }
        });
        priorityQueue2.offer(new Student(20));
        priorityQueue2.offer(new Student(22));
        priorityQueue2.offer(new Student(23));
        System.out.println(priorityQueue2);
    }

    public static void main1(String[] args) {
        MyPriorityQueue heap = new MyPriorityQueue();
        int[] arr = {27, 15, 19, 18, 28, 34, 65, 49, 25, 37};
        heap.initArray(arr);
        heap.createHeap();
        heap.push(100);
        //heap.pop();

        PriorityQueue<Integer>  priorityQueue1= new PriorityQueue<>();
        priorityQueue1.offer(4);
        priorityQueue1.offer(6);
        priorityQueue1.offer(3);
        System.out.println(priorityQueue1);

    }
}

有什么错误评论区指出，希望可以帮到你。

p_fly
关注
专栏目录
PriorityQueue优先队列中比较器Comparator的使用
qq_41845823的博客
04-19 4114
优先队列 java中的优先队列使用堆实现的，所以优先队列我们通常是拿来当大顶堆小顶堆使用 大顶堆和小顶堆的作用就是当我们想要获取大量数据的前几个最大或者最小的数据时使用的，因为如果对所有数据排序然后去前几个，时间复杂度最小也是O(nlogn)，使用堆的话时间复杂度为O(nlongm)，而 m 就是我们想要进行获取的前几个数，一般为常量，比如想要获取学校n个同学里面前8名，使用大顶堆获取的时间复杂度就是O(nlog8)。 如图所示是一种自下向上的建堆过程： 在java中优先队列的创建方法： //创建优先
java优先队列PriorityQueue中Comparator的用法
12-22
在使用java的优先队列PriorityQueue的时候，会看到这样的用法。 PriorityQueue queue = new PriorityQueue(new Comparator(){ @Override public int compare(Integer o1, Integer o2){ return o1.compareTo(o2); } }); 那这样到底构造的是最大优先还是最小优先队列呢？ 看看源码 看看offer（我也想要offer：X）： public boolean offer(E e) { if (e == null) {
【数据结构】优先级队列（堆）
最新发布
m0_73107796的博客
08-26 1843
掌握堆的概念及实现，掌握PriorityQueue 的使用
java优先队列PriorityQueue中Comparator的用法详解
08-25
主要介绍了java优先队列PriorityQueue中Comparator的用法详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
优先队列的比较器
qq_42799920的博客
11-05 672
PriorityQueue<Map.Entry<Integer,Integer>> queue = new PriorityQueue<>(new Comparator<Map.Entry<Integer,Integer>>(){ @Override public int compare(Map.Entry<Integer,Integer> o1,Map.Entry<Integer.
java 优先队列 用法_java优先队列PriorityQueue中Comparator的用法详解
weixin_30407555的博客
02-16 795
在使用java的优先队列PriorityQueue的时候，会看到这样的用法。PriorityQueue queue = new PriorityQueue(new Comparator(){@Overridepublic int compare(Integer o1, Integer o2){return o1.compareTo(o2);}});那这样到底构造的是最大优先还是最小优先队列呢？看看...
Comparator比较器介绍、优先级队列PriorityQueue
小小本科生
08-03 1585
比较器一：比较器的概念二：Comparable与Compartor的区别 一：比较器的概念 比较器的实质就是重载比较运算符 说到排序了，简单的说就是两个对象之间比较大小，那么在JAVA中提供了两种比较实现的方式，一种是比较死板的采用java.lang.Comparable接口去实现，一种是灵活的当我需要做排序的时候在去选择的java.util.Comparator接口完成。 Comparator这个接口，位于位于java.util包下，排序是comparator能实现的功能之一,该接口代表一个比较器，比较器
Java PriorityQueue（优先队列）详解
weixin_41174300的博客
06-10 622
在Java中，`PriorityQueue` 是一种基于优先级的队列，它的元素按照自然顺序或者由比较器指定的顺序进行排序。`PriorityQueue` 是 Java 集合框架的一部分，提供了在处理需要按照优先级顺序访问元素的场景时的极大便利。
Java优先级队列(堆)及对象的比较
dddddrrrzz的博客
01-13 685
目录一、二叉树的顺序存储1.1 存储方式1.2 下标关系二、堆（Heap）2.1 堆的相关概念2.2 操作-向下调整 一、二叉树的顺序存储 1.1 存储方式 使用数组保存二叉树结构，方式即将二叉树用层序遍历方式放入数组中。 一般只适合表示完全二叉树，因为非完全二叉树会有空间的浪费。这种方式的主要用法就是堆的表示。 1.2 下标关系 已知双亲(parent)的下标，则： 左孩子(left)下标 = 2 * parent + 1; 右孩子(right)下标 = 2 * parent + 2; 已知孩子（不
优先级队列中的 comparator() 的用法
实践求真知
08-27 566
Java
Java：PriorityQueue详解——从零基础到应用
流楚丶格念的博客
07-17 5332
看了网上的详解，我反是一篇没看懂，都是什么垃圾玩意也发出来，无语，我自己根据这两天的学习总结出来了下面这些干货，我就是这么学会的，大家要是零基础看肯定木问题。
java priorityqueue用法_Java PriorityQueue comparator()用法及代码示例
weixin_39767983的博客
02-26 579
java.util.PriorityQueue.comparator()方法具有一项重要的功能，即设置和返回比较器，该比较器可用于对PriorityQueue中的元素进行排序。如果队列遵循元素的自然排序模式，则该方法返回Null值。用法:comp_set = (PriorityQueue)Priority_Queue.comparator()参数：该方法不带任何参数。返回值：该方法返回用于以特定顺...
【数据结构与算法】优先队列中的比较器
weixin_45610907的博客
11-25 542
记录一下比较器的写法，以后要用时直接可以查阅（如果遇到新的写法会及时更新）
【Java学习笔记】45：优先级队列PriorityQueue和比较器Comparator
LauZyHou的笔记
12-14 4461
模拟进程调度时的优先数法和简单时间片轮转法，前者可以为进程设定以优先数PRIORITY为优先级，为了更好地并发，每次获得处理机后优先数减少3而重新选取。 在简单轮转法中则仅仅是一个普通队列，按照FIFO的方式出队获得处理机。如果要使用比较器Comparator给优先级队列，在创建时就应作为参数传入进去。Comparator通过覆写返回int值的正负来做判断，常使用匿名内部类。
java实现优先队列_Java优先队列(PriorityQueue)实现重写compare操作
weixin_39566864的博客
02-19 351
Java优先队列(PriorityQueue)实现重写compare操作发布时间：2020-10-29 15:15:11来源：亿速云阅读：82作者：Leah这篇文章将为大家详细讲解有关Java优先队列(PriorityQueue)实现重写compare操作，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。package myapp.kit.quicks...
记录一个Comparator例子
qq_40692756的博客
09-03 170
public class Main { public static void main(String[] args) { Queue<User> q = new PriorityQueue<>(new Comparator<User>() { public int compare(User u1, User u2) { if (u1.number.charAt(0) == u2.number.char...
Java~三种重写compare方法的PriorityQueue、TopK问题的解决思想附练习题（查找最小的K对数字与最后一块石头重量）
pCITv1C的博客
04-29 281
由于文案过于长，在此就不一一介绍了，这份Java后端架构进阶笔记内容包括：Java集合，JVM、Java并发、微服务、SpringNetty与 RPC 、网络、日志 、Zookeeper 、Kafka 、RabbitMQ 、Hbase 、MongoDB、Cassandra 、Java基础、负载均衡、数据库、一致性算法、Java算法、数据结构、分布式缓存等等知识详解。本知识体系适合于所有Java程序员学习，关于以上目录中的知识点都有详细的讲解及介绍，掌握该知识点的所有内容对你会有一个质的提升，
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值