1.. 优先队列(Priority Queue)
  • 优先队列与普通队列的区别:普通队列遵循先进先出的原则;优先队列的出队顺序与入队顺序无关,与优先级相关。
  • 优先队列可以使用队列的接口,只是在实现接口时,与普通队列有两处区别,一处在于优先队列出队的元素应该是优先级最高的元素,另一处在于队首元素也是优先级最高的元素。
  • 优先队列也可以使用不同的底层实现,不同底层实现的时间复杂度如下:
  • 从上图可以看出,使用"堆"这种数据结构来实现优先队列是比较高效的。
2.. 二叉堆(Binary Heap)
  • 二叉堆就是一棵满足特殊性质的二叉树
  • 首先,二叉堆是一棵完全二叉树,"完全二叉树",不一定是满二叉树,不满的部分一定位于整棵树的右下侧。
  • 其次,堆中某个节点的值总是不大于其父节点的值(最大堆);相应的,堆中的某个节点的值总是不小于其父节点的值(最小堆)。
  • 节点值的大小与其所处的层次没有必然联系,即,最大堆中,只需保证每个节点不大于其父节点即可,至于大不大于其父节点的兄弟节点,没有任何关系。
  • 可以用数组来存储二叉堆,如下图所示:
  • 用动态数组实现二叉堆的业务逻辑如下:
  • public class MaxHeap<E extends Comparable<E>> {
    
        private Array<E> data = new Array<>();
    
        // 构造函数
    public MaxHeap(int capacity) {
    data = new Array<>(capacity);
    } // 无参数构造函数
    public MaxHeap() {
    data = new Array<>();
    } // 接收参数为数组的构造函数
    public MaxHeap(E[] arr) {
    data = new Array<>(arr);
    for (int i = parent(arr.length - 1); i >= 0; i--) {
    SiftDown(i);
    }
    } // 实现getSize方法,返回堆中的元素个数
    public int getSize() {
    return data.getSize();
    } // 实现isEmpty方法,返回堆是否为空
    public boolean isEmpty() {
    return data.isEmpty();
    } // 返回完全二叉树的数组表示中,一个索引所表示的元素的父节点的索引
    private int parent(int index) {
    if (index == 0) {
    throw new IllegalArgumentException("Index-0 doesn't have parent.");
    }
    return (index - 1) / 2;
    } // 返回完全二叉树的数组表示中,一个索引所表示的元素的左孩子的索引
    private int leftChild(int index) {
    return index * 2 + 1;
    } // 返回完全二叉树的数组表示中,一个索引所表示的元素的右孩子的索引
    private int rightChild(int index) {
    return index * 2 + 2;
    } // 实现add方法,向堆中添加元素
    public void add(E e) {
    data.addLast(e);
    SiftUp(data.getSize() - 1);
    } // 实现元素的上浮
    private void SiftUp(int k) {
    while (k > 0 && data.get(parent(k)).compareTo(data.get(k)) < 0) {
    data.swap(k, parent(k));
    k = parent(k);
    }
    } // 实现findMax方法,查看堆中的最大元素
    public E findMax() {
    if (data.getSize() == 0) {
    throw new IllegalArgumentException("Can not findMax when heap is empty.");
    }
    return data.get(0);
    } // 实现extractMax方法,取出堆中的最大元素
    public E extractMax() {
    E ret = findMax();
    data.swap(0, data.getSize() - 1);
    data.removeLast();
    SiftDown(0);
    return ret;
    } // 实现元素的下沉
    private void SiftDown(int k) {
    while (leftChild(k) < data.getSize()) {
    int j = leftChild(k);
    if (j + 1 < data.getSize() && data.get(j + 1).compareTo(data.get(j)) > 0) {
    j = rightChild(k);
    // data[j]是leftChild和rightChild中的对大值
    }
    if (data.get(k).compareTo(data.get(j)) >= 0) {
    break;
    } else {
    data.swap(k, j);
    k = j;
    }
    }
    } // 实现replace方法,取出堆中的最大元素,并替换为元素e
    public E replace(E e) {
    E ret = findMax();
    data.set(0, e);
    SiftDown(0);
    return ret;
    }
    }
  • 测试用动态数组实现的二叉堆
  • import java.util.Random;
    
    public class Main {
    
        public static void main(String[] args) {
    
            int n = 1000000;
    MaxHeap<Integer> maxHeap = new MaxHeap<>();
    Random random = new Random();
    for (int i = 0; i < n; i++) {
    maxHeap.add(random.nextInt(Integer.MAX_VALUE));
    } int[] arr = new int[n];
    for (int i = 0; i < n; i++) {
    arr[i] = maxHeap.extractMax();
    } for (int i = 1; i < n; i++) {
    if (arr[i - 1] < arr[i]) {
    throw new IllegalArgumentException("Error");
    }
    } System.out.println("Test MaxHeap completed.");
    }
    }
  • 二叉堆的时间复杂度分析
  • 由于堆是一棵完全二叉树,所以堆不会退化成链表。
3.. 用最大堆实现一个优先队列(Priority Queue)
  • 实现优先队列的业务逻辑如下:
  • public class PriorityQueue<E extends Comparable<E>> implements Queue<E> {
    
        private MaxHeap<E> maxHeap;
    
        // 构造函数
    public PriorityQueue() {
    maxHeap = new MaxHeap<>();
    } // 实现getSize方法
    @Override
    public int getSize() {
    return maxHeap.getSize();
    } // 实现isEmpty方法
    @Override
    public boolean isEmpty() {
    return maxHeap.isEmpty();
    } // 实现getFront方法
    @Override
    public E getFront() {
    return maxHeap.findMax();
    } // 实现enqueue方法
    @Override
    public void enqueue(E e) {
    maxHeap.add(e);
    } // 实现dequeue方法
    @Override
    public E dequeue() {
    return maxHeap.extractMax();
    }
    }
4.. 优先队列的应用:从N个元素中,选出前M个
  • 解决方案:使用优先队列,维护当前的M个元素,然后不断更新元素,直到扫描完所有N个元素。
  • 需要使用"最小堆"来进行底层的实现,因为最终获取的是前M个元素,通过最小堆的extractMin方法,可以不断的剔除堆中的最小元素
  • 也可以使用最大堆来实现,我们只要规定元素越小,优先级越高。
  • 使用最小堆实现的业务逻辑如下:
  • import java.util.List;
    import java.util.PriorityQueue;
    import java.util.TreeMap; public class Solution2 { private class Freq implements Comparable<Freq> { public int e, freq; public Freq(int e, int freq) {
    this.e = e;
    this.freq = freq;
    } public int compareTo(Freq another) {
    if (this.freq < another.freq)
    return -1;
    else if (this.freq > another.freq)
    return 1;
    else
    return 0;
    }
    } public List<Integer> topKFrequent(int[] nums, int k) { TreeMap<Integer, Integer> map = new TreeMap<>();
    for (int num : nums) {
    if (map.containsKey(num))
    map.put(num, map.get(num) + 1);
    else
    map.put(num, 1);
    } PriorityQueue<Freq> pq = new PriorityQueue<>();
    for (int key : map.keySet()) {
    if (pq.size() < k)
    pq.add(new Freq(key, map.get(key)));
    else if (map.get(key) > pq.peek().freq) {
    pq.remove();
    pq.add(new Freq(key, map.get(key)));
    }
    } LinkedList<Integer> res = new LinkedList<>();
    while (!pq.isEmpty())
    res.add(pq.remove().e);
    return res;
    }
    }

第二十八篇 玩转数据结构——堆(Heap)和有优先队列(Priority Queue)的更多相关文章

  1. 第二十九篇 玩转数据结构——线段树(Segment Tree)

          1.. 线段树引入 线段树也称为区间树 为什么要使用线段树:对于某些问题,我们只关心区间(线段) 经典的线段树问题:区间染色,有一面长度为n的墙,每次选择一段墙进行染色(染色允许覆盖),问 ...

  2. 第二十六篇 玩转数据结构——二分搜索树(Binary Search Tree)

          1.. 二叉树 跟链表一样,二叉树也是一种动态数据结构,即,不需要在创建时指定大小. 跟链表不同的是,二叉树中的每个节点,除了要存放元素e,它还有两个指向其它节点的引用,分别用Node l ...

  3. 第二十五篇 玩转数据结构——链表(Linked List)

          1.. 链表的重要性 我们之前实现的动态数组.栈.队列,底层都是依托静态数组,靠resize来解决固定容量的问题,而"链表"则是一种真正的动态数据结构,不需要处理固定容 ...

  4. 第二十四篇 玩转数据结构——队列(Queue)

          1.. 队列基础 队列也是一种线性结构: 相比数组,队列所对应的操作数是队列的子集: 队列只允许从一端(队尾)添加元素,从另一端(队首)取出元素: 队列的形象化描述如下图: 队列是一种先进 ...

  5. Android UI开发第二十八篇——Fragment中使用左右滑动菜单

    Fragment实现了Android UI的分片管理,尤其在平板开发中,好处多多.这一篇将借助Android UI开发第二十六篇——Fragment间的通信. Android UI开发第二十七篇——实 ...

  6. 算法与数据结构基础 - 堆(Heap)和优先级队列(Priority queue)

    堆基础 堆(Heap)是具有这样性质的数据结构:1/完全二叉树 2/所有节点的值大于等于(或小于等于)子节点的值: 图片来源:这里 堆可以用数组存储,插入.删除会触发节点shift_down.shif ...

  7. Python之路【第二十八篇】:生成器与迭代器

    #!/usr/bin/env python # -*- coding:utf-8 -*- #只要函数的代码里面出现了yield关键字,这个函数就不再是一个普通的函数了,叫做生成器函数 #执行生成器函数 ...

  8. Python之路(第二十八篇) 面向对象进阶:类的装饰器、元类

    一.类的装饰器 类作为一个对象,也可以被装饰. 例子 def wrap(obj): print("装饰器-----") obj.x = 1 obj.y = 3 obj.z = 5 ...

  9. Python之路【第二十八篇】:django视图层、模块层

    1.视图函数 文件在view_demo 一个视图函数简称视图,是一个简单的Python 函数,它接受Web请求并且返回Web响应.响应可以是一张网页的HTML内容,一个重定向,一个404错误,一个XM ...

随机推荐

  1. Windows2008r2、正版安装包

    最近发现有很多人找我要Windows  2008的安装包,为了方便,就分享在这儿一下,有需要的自行下载. 链接:https://pan.baidu.com/s/1YZFE7FxL8O_gtfAftcX ...

  2. mybatis-plus热部署mapper.xml插件JRebel MybatisPlus extension,报错:java.lang.NullPointerException

    事件 mybatis转mybatis-plus,结果原来的Jrebel for intrllij 不能热部署mapper.xml文件,百度得知得添加新的插件 JRebel MybatisPlus ex ...

  3. K3/Cloud 执行计划任务错误排查

    计划任务的不执行原因可能有: 1.K3CloudJobProcess服务处于停止状态. 2.数据中心未勾选“允许执行计划任务”. 这种情况此数据中心下的所有计划任务都不会执行到. 3.第一次加进计划任 ...

  4. Wannafly Camp 2020 Day 2K 破忒头的匿名信 - AC自动机,dp

    给定字典和文章,每个单词有价值,求写文章的最小价值 标准的 AC 自动机 dp,设 \(f[i]\) 表示写 \(s[1..i]\) 的最小价值,建立AC自动机后根据 trans 边暴力转移即可 建了 ...

  5. Python标准库之sys模块

    获取Python解释器的版本信息 import sys print(sys.version) #输出 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) ...

  6. Response与ServletContext对象

    HTTP协议: 请求消息:客户端发送给服务器端的数据 数据格式: 请求行: 格式: 请求方式 请求url 请求协议/版本 请求头:告诉服务器,当前访问的浏览器自身的一些信息 格式: 请求头名称: 请求 ...

  7. poj1321棋盘问题(dfs+摆放问题)

    在一个给定形状的棋盘(形状可能是不规则的)上面摆放棋子,棋子没有区别.要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列,请编程求解对于给定形状和大小的棋盘,摆放k个棋子的所有可行的摆放方案C. ...

  8. 本地项目如何上传到github

      首先登录官网注册用户(此处不多介绍),然后需要登录github创建仓库 https://github.com/ 然后取一个自己喜欢的名字(这里我的名字是webclock),点击Create rep ...

  9. 简单易用,用Powershell劫持Windows系统快捷键

    POC:  $WshShell = New-Object -comObject WScript.Shell $Shortcut = $WshShell.CreateShortcut("des ...

  10. 第一篇 网站基础知识 第5章 自己动手实现HTTP协议

    第5章 自己动手实现HTTP协议 我们知道HTTP协议是在应用层解析内容的,只需要按照它的报文的格式封装和解析数据就可以了,具体的传输还是使用的Socket,在第4章NioServer的基础上自己做一 ...