【数据结构】优先级队列的实际应用之TopK问题

已于 2022-08-01 11:22:54 修改
阅读量185 收藏
点赞数
分类专栏： 数据结构 算法 文章标签： java 开发语言 排序算法
于 2022-07-28 11:46:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57549633/article/details/126025712
版权
1.前置知识—对象大小的比较

整形、浮点型等数值型大小的比较，直接比较值的大小即可，而对象间大小的比较，有以下两种方式：

  • 实现Comparable接口，重写compareTo方法

一个类一旦实现了Comparable接口，就表明当前类具备了可比较大小的能力，根据compareTo的返回值确定对象间的大小。

public class Test1 {

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

        public Student(String name,int age){
            this.name =name;
            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 static void main(String[] args) {
        Student s1 =new Student("胡歌",30);
        Student s2 =new Student("江江",24);
        Student s3 =new Student("浩存",00);
        Student[] students =new Student[]{s1,s2,s3};
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

执行结果：
在这里插入图片描述
着重注意compareTo方法的返回值：在这里插入图片描述
要知道java中 Arrays.sort(）方法默认是按升序排列，此处在compareTo方法中执行策略是按年龄的降序排列。

  • 实现Comparator接口，重写compare方法

与Comparable相似，一个类一旦实现了Comparator接口，就表明当前类具备了可比较大小的能力，根据compare的返回值确定对象间的大小。

public class Test2 {

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

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

        public int getAge() {
            return age;
        }

        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    /**
     * 升序的比较器
     */
    static class StudentAsc implements Comparator<Student>{
        @Override
        public int compare(Student o1, Student o2) {
            return o1.getAge()-o2.getAge();
        }
    }
    /**
     * 降序的比较器
     */
    static class StudentDesc implements Comparator<Student>{
        @Override
        public int compare(Student o1, Student o2) {
            return o2.getAge()-o1.getAge();
        }
    }

    public static void main(String[] args) {
        Student s1 =new Student("胡歌",30);
        Student s2 =new Student("江江",24);
        Student s3 =new Student("浩存",00);
        Student[] students =new Student[]{s1,s2,s3};
        Arrays.sort(students,new StudentAsc());
        System.out.println(Arrays.toString(students));
        Arrays.sort(students,new StudentDesc());
        System.out.println(Arrays.toString(students));
    }
}

执行结果：
在这里插入图片描述

从以上结果中看出，在排序过程中传入不同的比较策略就可以得到不同的排序结果，但是Comparator相比较Comparable来说更加灵活，无需修改类的代码，属于无侵入式编程。

2.自定义比较器实现优先级队列

自定义一个降序的比较器，创建优先级队列时传入比较器

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;

public class Test3 {

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

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

        public int getAge() {
            return age;
        }

        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    /**
     * 升序的比较器
     */
    static class StudentAsc implements Comparator<Student>{
        @Override
        public int compare(Student o1, Student o2) {
            return o1.getAge()-o2.getAge();
        }
    }

    public static void main(String[] args) {
        Student s1 =new Student("胡歌",30);
        Student s2 =new Student("江江",24);
        Student s3 =new Student("浩存",20);
      //1.比较器写法
        Queue<Student> queue =new PriorityQueue<>(new StudentDesc());
        //2.匿名内部类写法
        Queue<Student> queue1 =new PriorityQueue<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o2.age-o1.getAge();
            }
        });
        //3.lambda表达式
        Queue<Student> queue2 =new PriorityQueue<>(((o1, o2) -> o2.age- o1.age));
        queue.offer(s1);
        queue.offer(s2);
        queue.offer(s3);
        while (!queue.isEmpty()){
            System.out.println(queue.poll());
        }
    }
}

执行结果：
在这里插入图片描述

3.优先级队列的实际应用—TopK问题

最大堆性质:堆顶元素是最大值，你是要找小的，若扫描的元素大于堆顶元素，则大于堆中的所有值，这个值一定不是你要找的值。
经典TopK问题
1.数组中最小K个数

public class Lc1714_SmallestK {

    /**
     * 数组中前K个最小数
     * @param arr
     * @param k
     * @return
     */
    public int[] smallestK(int[] arr, int k) {
    //边界条件
        if (arr.length ==0 || k==0){
        return new int[0];
    }
        //构造一个基于最大堆的优先级队列
        Queue<Integer> queue =new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        //遍历数组，将数组中最大的k个数放入队列中
        for (int i : arr) {
            //队列中元素小于k，直接入队
            if (queue.size()<k){
                queue.offer(i);
            }else {
                //此时，队列已满，取出堆顶元素,判断当前元素和堆顶元素的大小
                 int peek = queue.peek();
                 if (peek<i){
                     //当前元素大于堆顶元素
                     continue;
                 }else {
                     //当前元素小于堆顶元素，则一定小于堆中所有的元素，堆顶元素出队，将当前元素入队
                     queue.poll();
                     queue.offer(i);
                 }
            }
        }
        //此时，堆中就保存了最小的k个数
        int[] ret =new int[k];
        for (int i = 0; i < k; i++) {
            ret[i] =queue.poll();
        }
        return ret;
    }
}

2.前 K 个高频元素

class Solution {
       public int[] topKFrequent(int[] nums, int k) {
        //定义一个map集合存储数组元素出现的次数
        Map<Integer, Integer> map = new HashMap<>();
        for (int num : nums) {
            if (map.containsKey(num)) {
                map.put(num, map.get(num) + 1);
            } else {
                map.put(num, 1);
            }
        }
        //构造一个最小堆保存最大得K个元素
        PriorityQueue<Integer> queue = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return map.get(o1) - map.get(o2);
            }
        });
        //遍历map集合，保存最大的K个元素
        for (Integer key : map.keySet()) {
            //队列还未满时，直接将元素入队
            if (queue.size() < k) {
                queue.offer(key);
            } else if (map.get(key) > map.get(queue.peek())) {
                //将堆顶元素出队
                queue.poll();
                queue.offer(key);
            }
        }   
        //此时的堆就保存最大的K个元素
        int[] ret = new int[k];
        for (int i = 0; i < k; i++) {
            ret[i] = queue.poll();
        }
        return ret;
    }
}

3.查找和最小的 K 对数字

class Solution {
 public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {
        //构造一个大根堆
        Queue<List<Integer>> queue =new PriorityQueue<>(((o1, o2) -> (o2.get(0)+o2.get(1))-(o1.get(0)+o1.get(1))));
        int n1 = nums1.length;;
        int n2= nums2.length;
        for (int i = 0; i < n1; i++) {
            for (int j = 0; j < n2; j++) {
                int sum =nums1[i]+nums2[j];
                List<Integer> list =new ArrayList<>();
                //每次存入一组数对到集合
                list.add(nums1[i]);
                list.add(nums2[j]);
                if (queue.size()<k) {
                    //队列未满，直接将集合加入队列
                    queue.offer(list);
                }else {
                    //取出堆顶元素和
                    int s =queue.peek().get(0)+queue.peek().get(1);
                    if (s>sum){
                        //堆顶元素之和大于当前数组和
                        queue.poll();
                        queue.offer(list);
                    }else {
                        break;
                    }
                }
            }
        }
        //此时优先级队列中就存储了前k小个数对
     List<List<Integer>> ans =new ArrayList<>(queue);
        return ans;
    }
}

总结，以上三个题型是比较经典的TopK问题，TopK的其他问题解法与之类似，TopK问题的另一种解法就是排序，但在数量级比较大的情况下，构造一个最大/小堆来解决问题，时间复杂度在NlogN，效率就要高很多。

Money、坤
关注
专栏目录
优先级队列解决TopK问题
m0_61630116的博客
05-23 552
首先我们需要了解什么是TopK问题，那就是给你一个一组数据，数据可能很少或者很多，让你找到前K小或者前K大的数据。当数据比较少的时候我们可以使用暴力解法，那就是直接对整个数据进行排序处理，然后取前K个元素那就是答案，但是当数据非常多的时候，效率也会变得相对比较慢。 以上所述，直接排序对数据量很大的场景是不太合适的，所以我们利用优先级队列来解决TopK问题，我们设想一下，我们要找前K大的数据，这时候我们的优先级队列要实现一个大堆还是一个小堆？答案是小堆，当我们把题目要求K个元素放入堆中之后，就形成了一个..
MapReduce TopK问题实际应用
lavimer
01-28 4268
一：背景 TopK问题应该是海量数据处理中应用最广泛的了，比如在海量日志数据处理中，对数据清洗完成之后统计某日访问网站次数最多的前K个IP。这个问题的实现方式并不难，我们完全可以利用MapReduce的Shuffle过程实现排序，然后在Reduce端进行简单的个数判断输出即可。这里还涉及到二次排序，不懂的同学可以参考我之前的文章。 二：技术实现 #我们先来看看一条Ngnix服务器的日
优先级队列（堆）——top-K问题
weixin_53033446的博客
05-14 205
堆(heap) 堆的概念 堆在逻辑上是一棵完全二叉树 堆物理上是保存在数组中 满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆 满足任意结点的值都小于其子树中结点的值，叫做小堆，或者小根堆，或者最下堆 创建堆（代码） //调整 public static void shiftDown(int[] array, int size, int index) { int left = 2 * index + 1; while (left < size) { in
优先队列实现TopK排序问题
weixin_52828997的博客
06-14 187
简单代码实现TopK排序问题。随机生成数据并取出最大的k个数据。优先队列实现。
top-k的应用
weixin_39238424的博客
03-15 737
top-k的应用 topk指的是，保存一段数据的最大或者最小的k位数，在code中或者工程中右很重要的应用。 举例： 查询超大量数据中 最小或者最大的 第 k位数。 正常使用排序 缺点：内存占用会超出正常范围 相对简单的做法是，遍历K次，每次选出最小（或者最大的）数。最后返回结果 缺点：时间复杂度为KN，而且需要删除原数据中的数或者要在已有数据中进行判断 简化： 形成一个topk的 最大堆。内部使...
优先级队列TOPK问题
m0_68989458的博客
05-19 345
优先级队列TOPK问题
堆（优先级队列）及TOPK问题详解
qq_49425839的博客
10-22 433
@[TOC]二叉树的顺序存储 #存储方式 老铁们首先声明一下，此堆非彼堆，jvm中有堆、栈等，属于存储结构，我们这里讨论的堆为数据结构。 1.二叉树的顺序存储 1.1存储方式 使用数组保存二叉树结构，方式即将二叉树用层序遍历方式放入数组中。 一般只适合表示完全二叉树，因为非完全二叉树会有空间的浪费。 这种方式的主要用法就是堆的表示。 1.2下标关系 已知双亲(parent)的下标，则： 左孩子(left)下标 = 2 * parent + 1; 右孩子(right)下标 = 2 * parent + 2;
【数据结构】堆和优先级队列
最新发布
m0_50987960的博客
12-02 907
堆的构建和基本方法的实现以及TopK问题。
数据结构基础——优先级队列（堆）
m0_58421666的博客
06-12 656
普通队列：按照元素的入队顺序出队，先入先出。优先级队列：按照优先级的大小动态出队（动态指的是元素个数动态变化，而非固定）。优先级队列的数据是在动态变化的。时间复杂度对比：堆有很多种（d叉堆、索引堆…），二叉堆是应用最广泛的堆。是一棵完全二叉树，基于数组存储（元素都是靠左排列，数组中存储不会浪费空间）关于节点值：堆中根节点值 >= 子树节点中的值（最大堆、大根堆）堆中根节点值 = 子树 最大堆​ 根 ......
数据结构之优先级队列
莫予笙的博客
05-06 1244
优先级队列 概念 队列是一种先进先出（FIFO）的数据结构。 但在有些情况下，我们进行操作的数据可能带有优先级，在出队列时可能需要优先级高的先出队列。因此，把具有返回优先级最高的对象和添加新对象操作的数据结构称为优先级队列（PriorityQueue）。 基本特性 使用时必须导入PriorityQueue所在的包： import java.util.PriorityQueue; Prior...
Java-PriorityQueue:任务优先级队列的实现
04-02
任务的优先队列 基于任务的PriorityQueue的实现在此程序中，用户可以： 注册新任务，并传递名称和优先级 提取并返回列表中优先级最低的任务 清除任务列表 列出所有待处理的任务及其优先级 导入和导出CSV文件中的任务列表 退出该程序，并提醒其有待完成的任务
堆的实现及应用（优先级队列，堆排，TopK问题）
pigff的博客
10-15 1721
堆数据结构是一种数组对象，它可以被看做是一棵完全二叉树。 堆的二叉树存储有两种方式： 1.最大堆：每个父节点的值都大于孩子节点 2.最小堆：每个父节点的值都小于小子节点 如上图所示就是一个最小堆。 关于堆，其实说到底就是两种算法，一种是向下调整算法，一种是向上调整算法。我们先结合图来分析一下这两种算法。 就拿上图来说，上图是一个小堆，接下来比如说我们要往里插入一个9，那么因为堆的底...
经典TopK问题、优先级队列 与 堆的纠葛一文为你解惑——数据结构
honglan297的博客
07-13 1145
本片文章以 TopK 问题为引，具体阐述了 PriorityQueue 实现的基本逻辑——堆数据结构，以及PriorityQueue 的常用方法
堆结构的两个重要应用（topk问题，堆排序）
qq_52777887的博客
03-19 1797
堆结构体有什么用？堆排序 & topK 你值得拥有
算法学习笔记——数据结构：优先队列/堆（TopK问题）
Insomnia_X的博客
07-11 250
堆是自带排序功能的数据结构，其本质是完全二叉树，但为了方便，用数组存储；在使用过程中，保证任意父节点的值一定大于或等于/小于或等于子节点，Python中用`heapq`库来实现堆
快排算法，以及 top_k应用
曾经最动心的专栏
08-29 538
快速排序 的思想是 以最左边的数值为基准，将它放在一个位置，使左边的数都比它小，右边的数都比它大，然后递归 举个例子来说： 4,2,1,5,7,8,2,3,7  这9个数 首先sort(0,8)  以最左边a[0]=4为基准，经过一系列调整过程 变成这样 3 2 1 2 4 8 7 5 7，4现在的位置是4，而且左边都比它小，右边都比它大，然后我们递归sort(0,3) sort(5,8
TopK——寻找热词
杨杨子江的博客
09-04 350
Topk的简单介绍,用于寻找前K个最大值，也可以用于寻找“热词”。 Topk
Top-k高效用项集挖掘_学习笔记(一) 基础概念
Erpim的博客
04-23 3641
前言 本篇博客出于学习交流目的，主要是用来记录自己学习后的理解，过程中遇到的问题和心路历程，方便之后回顾。过程中可能引用其他大牛的博客，文末会给出相应链接，侵删！ REMARK：本人菜鸟一枚，如有理解错误还望大家能够指出，相互交流。也是第一次以博客的形式记录，文笔烂到自己都看不下去，哈哈哈 这篇学习笔记关于一种高效Top-k的频繁效用项集挖掘算法。 参考文献：Effic...
有关优先队列问题的一些整理
Fc1602的博客
05-11 515
首先，先说说优先队列重载格式 注意：这里的x<y建立出来的优先队列是降序的，大的在前面，可以理解成x<y这个式子如果成立就执行交换操作，让大的那个到前面去。默认优先队列也是降序的。 然后就是做优先队列题目的一些小思路 1.题目链接：1011-小A与任务_2021秋季算法入门班第五章习题：优先队列、并查集 (nowcoder.com) 如这道题目该如何用优先队列去解它，那么在此之前我们要先了解优先队列的用途，在做优先队列题目时我们必须要明白优先队列与...
LeetCode堆题解与TopK应用
在这个笔记中，我们将深入探讨堆在LeetCode编程挑战中的应用，尤其是针对堆排序和优先级队列的题目。堆是一种特殊的树形数据结构，它具有两个主要类型：大顶堆（最大堆）和小顶堆（最小堆）。在完全二叉树中，堆的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值