当前位置： 首页 > news >正文

基于二叉堆实现的 PriorityQueue

news 来源：原创 2025/6/9 15:23:19

基于二叉堆实现的 PriorityQueue 是一种常见的数据结构，广泛用于任务调度、路径搜索、事件模拟等场景。下面我将用 Java 语言实现一个简单的基于最小堆的 PriorityQueue，即优先级最小的元素先出队。

✅ 实现目标

  • 使用数组实现二叉最小堆（即父节点 ≤ 子节点）
  • 支持以下基本操作：
    • add(E element)
    • peek()
    • poll()
    • size()
    • 自动扩容

🚀 实现代码（Java）

import java.util.Arrays;
import java.util.NoSuchElementException;

public class MyPriorityQueue<E extends Comparable<E>> {
    private static final int DEFAULT_CAPACITY = 16;
    private Object[] heap;
    private int size;

    public MyPriorityQueue() {
        heap = new Object[DEFAULT_CAPACITY];
        size = 0;
    }

    public void add(E element) {
        if (element == null) throw new NullPointerException();
        ensureCapacity();
        heap[size] = element;
        siftUp(size);
        size++;
    }

    public E peek() {
        if (size == 0) throw new NoSuchElementException();
        return elementAt(0);
    }

    public E poll() {
        if (size == 0) throw new NoSuchElementException();
        E result = elementAt(0);
        heap[0] = heap[size - 1];
        heap[size - 1] = null;
        size--;
        siftDown(0);
        return result;
    }

    public int size() {
        return size;
    }

    private void ensureCapacity() {
        if (size >= heap.length) {
            heap = Arrays.copyOf(heap, heap.length * 2);
        }
    }

    private void siftUp(int index) {
        Object temp = heap[index];
        while (index > 0) {
            int parent = (index - 1) / 2;
            if (((E) temp).compareTo(elementAt(parent)) >= 0) break;
            heap[index] = heap[parent];
            index = parent;
        }
        heap[index] = temp;
    }

    private void siftDown(int index) {
        Object temp = heap[index];
        int half = size / 2;
        while (index < half) {
            int left = 2 * index + 1;
            int right = left + 1;
            int smallest = left;
            if (right < size && elementAt(right).compareTo(elementAt(left)) < 0) {
                smallest = right;
            }
            if (((E) temp).compareTo(elementAt(smallest)) <= 0) break;
            heap[index] = heap[smallest];
            index = smallest;
        }
        heap[index] = temp;
    }

    @SuppressWarnings("unchecked")
    private E elementAt(int index) {
        return (E) heap[index];
    }
}

📦 示例用法

public class Main {
    public static void main(String[] args) {
        MyPriorityQueue<Integer> pq = new MyPriorityQueue<>();
        pq.add(5);
        pq.add(2);
        pq.add(9);
        pq.add(1);

        while (pq.size() > 0) {
            System.out.println(pq.poll());
        }
    }
}

输出：

1
2
5
9

如果你需要最大堆版本，只需把比较逻辑反过来即可。

下面是对上面代码的扩展版本，支持传入自定义的 Comparator，从而实现更灵活的排序逻辑，比如最大堆、自定义字段排序等。

✅ 改造目标

  • 支持传入 Comparator<E>，代替 Comparable<E> 进行元素比较。
  • 如果未传入 Comparator，则默认使用元素的自然顺序（即要求 E implements Comparable<E>）。

🚀 改造后的 Java 实现：支持 Comparator 的 PriorityQueue

import java.util.Arrays;
import java.util.Comparator;
import java.util.NoSuchElementException;

public class MyPriorityQueue<E> {
    private static final int DEFAULT_CAPACITY = 16;
    private Object[] heap;
    private int size;
    private final Comparator<? super E> comparator;

    public MyPriorityQueue() {
        this(null);
    }

    public MyPriorityQueue(Comparator<? super E> comparator) {
        this.comparator = comparator;
        this.heap = new Object[DEFAULT_CAPACITY];
        this.size = 0;
    }

    public void add(E element) {
        if (element == null) throw new NullPointerException();
        ensureCapacity();
        heap[size] = element;
        siftUp(size);
        size++;
    }

    public E peek() {
        if (size == 0) throw new NoSuchElementException();
        return elementAt(0);
    }

    public E poll() {
        if (size == 0) throw new NoSuchElementException();
        E result = elementAt(0);
        heap[0] = heap[size - 1];
        heap[size - 1] = null;
        size--;
        siftDown(0);
        return result;
    }

    public int size() {
        return size;
    }

    private void ensureCapacity() {
        if (size >= heap.length) {
            heap = Arrays.copyOf(heap, heap.length * 2);
        }
    }

    private void siftUp(int index) {
        Object temp = heap[index];
        while (index > 0) {
            int parent = (index - 1) / 2;
            if (compare((E) temp, elementAt(parent)) >= 0) break;
            heap[index] = heap[parent];
            index = parent;
        }
        heap[index] = temp;
    }

    private void siftDown(int index) {
        Object temp = heap[index];
        int half = size / 2;
        while (index < half) {
            int left = 2 * index + 1;
            int right = left + 1;
            int smallest = left;
            if (right < size && compare(elementAt(right), elementAt(left)) < 0) {
                smallest = right;
            }
            if (compare((E) temp, elementAt(smallest)) <= 0) break;
            heap[index] = heap[smallest];
            index = smallest;
        }
        heap[index] = temp;
    }

    @SuppressWarnings("unchecked")
    private E elementAt(int index) {
        return (E) heap[index];
    }

    private int compare(E a, E b) {
        if (comparator != null) {
            return comparator.compare(a, b);
        }
        return ((Comparable<? super E>) a).compareTo(b);
    }
}

📦 示例用法

✅ 默认最小堆

MyPriorityQueue<Integer> pq = new MyPriorityQueue<>();
pq.add(4);
pq.add(1);
pq.add(7);
System.out.println(pq.poll()); // 输出 1

✅ 最大堆（传入自定义 Comparator）

MyPriorityQueue<Integer> maxHeap = new MyPriorityQueue<>((a, b) -> b - a);
maxHeap.add(4);
maxHeap.add(1);
maxHeap.add(7);
System.out.println(maxHeap.poll()); // 输出 7

✅ 自定义对象排序（按年龄升序）

class Person {
    String name;
    int age;

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

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

MyPriorityQueue<Person> peopleQueue = new MyPriorityQueue<>(
    Comparator.comparingInt(p -> p.age)
);

peopleQueue.add(new Person("Alice", 30));
peopleQueue.add(new Person("Bob", 25));
peopleQueue.add(new Person("Carol", 35));

System.out.println(peopleQueue.poll()); // 输出 Bob(25)

如果你还有其他定制需求，比如：

  • 支持删除任意元素
  • 支持更新某个元素的优先级
  • 支持构造函数初始化时传入一个集合

基于二叉堆实现的 PriorityQueue 因其高效的插入和删除最小（或最大）元素操作，在很多应用场景中都有着广泛的运用。下面我详细介绍几个常见的应用场景：

1. 图算法：路径搜索与最短路径

Dijkstra 算法

在 Dijkstra 算法中，优先队列用来维护从起点到各个节点的当前最短路径距离。每次从优先队列中选出距离最小的节点，然后根据这个节点更新其邻接点的距离。借助基于二叉堆的 PriorityQueue，其对插入和删除操作的平均时间复杂度为 O(log n)，使得算法在稀疏图中的效率大为提升。

A* 搜索算法

类似于 Dijkstra 算法，A* 算法也需要一个优先队列来维护待搜索节点，并根据预估函数 f(n)=g(n)+h(n) 的值来排列节点的优先级。使用二叉堆实现的 PriorityQueue 能够快速选取当前估值最低的节点，从而提高搜索效率。

2. 事件调度和仿真系统

离散事件模拟

在离散事件仿真系统中，每个事件都有一个触发时间，需要按照时间顺序执行。使用二叉堆实现的 PriorityQueue，可以将所有待执行事件按照时间顺序排列，每次只取最早触发的事件进行处理。这样的调度机制保证了事件的正确时序，适用于物流调度、网络仿真、制造系统仿真等场景。

操作系统任务调度

操作系统调度程序中也经常用到优先队列。比如在多任务系统中，任务可能具有不同的优先级或者截止时间。基于二叉堆的 PriorityQueue 可以迅速确定下一个需要处理的任务，有助于实现实时性要求较高的调度算法。

3. 排序和 Top-K 问题

堆排序

堆排序算法就是利用堆这种数据结构实现的排序算法。首先将数据构成一个堆，然后不断取出堆顶元素（最小/最大），并将剩余元素重新调整成堆结构。堆排序的时间复杂度为 O(n log n)，适合在部分特殊场景下使用。

查找 Top-K 元素

在海量数据中查找前 K 个最小或最大的元素，可以利用一个固定大小的 PriorityQueue。对每个新数据，和队列中的最值进行比较，若满足条件就进行替换操作，这样能够在 O(n log k) 的时间内找出前 K 个元素，非常适合实时数据处理与流式计算。

4. 网络和流量管理

网络路由与转发

在网络数据包调度和路由选择中，优先队列可以根据数据包的紧急程度、传输延迟等属性来决定数据包的传输顺序。使用基于二叉堆的实现，能够有效管理大量数据包，保证网络传输的高效和公平性。

服务质量（QoS）调控

在一些需要区分服务等级的场景（例如 VOIP、视频流处理等），采用 PriorityQueue 可以确保高优先级数据（如实时音视频数据）优先传输，从而改善用户体验。

5. 金融和交易系统

高频交易系统

金融领域中的高频交易系统通常需要实时处理大量订单，并保证订单按照某种优先级（如价格、时间等）进行匹配。PriorityQueue 能够高效维护待处理的订单列表，使得交易处理的响应时间尽可能低。

风险管理

在风险评估和管理场景中，不同投资组合或交易策略可能具有不同的风险度量值。利用 PriorityQueue，可以快速锁定风险较高的部分并及时采取措施，实现高效监控和决策。

总结

基于二叉堆实现的 PriorityQueue 以其简单、高效的特性，在图算法、事件调度、任务调度、排序以及网络、金融等众多领域都有重要应用。其对插入、删除操作时间复杂度为 O(log n) 的优势，使得在数据量较大、实时性要求较高的场景中表现优异。通过支持自定义比较器，PriorityQueue 更加灵活，可以方便地应用在各种复杂的业务场景中。

相关文章：

  • LLM应用实战2-理解Tokens
  • C语言malloc类函数详解
  • Linux C 与 C 语言的区别及开发差异
  • Spring MVC 请求类型注解详解
  • Java-多级排序结合thenComparing()
  • 四六级听力考试播音系统:构建播放控制智能化、发射系统双备份、发射功率有冗余、安全稳定可靠的英语四六级听力播音系统使用环境
  • vue-element-plus-admin的安装
  • pytorch小记（十六）：PyTorch中的`nn.Identity()`详解：灵活模型设计的秘密武器
  • Linux内核——X86分页机制
  • I/O进程4
  • 动态规划系列一＞卡特兰数-不同的二叉搜索树
  • C# 串口通信
  • 全新二手罗德SMCV100B信号发生器SMBV100A
  • 视频融合平台EasyCVR搭建智慧粮仓系统：为粮仓管理赋能新优势
  • 对象的创建方式有哪些?在虚拟机中具体的创建过程是怎样的？
  • Conda使用方法详解
  • SAM: 一切皆可分割
  • NO.82十六届蓝桥杯备战|动态规划-从记忆化搜索到动态规划|下楼梯|数字三角形(C++)
  • 【在团队中有效表达想法的方法】
  • WPF 组件的宽高绑定另一个组件的宽高的指定比值
  • 4线城市搞网站开发/免费个人网站注册
  • 在微信怎么开发公众号/seo建站公司推荐
  • 洛阳建设厅网站/今日竞彩足球最新比赛结果查询
  • 酒泉市建设局网站招标办/网址解析ip地址
  • 山东中恒建设集团网站/公司网站建设哪个好
  • 外贸企业网站模板/南宁做网站公司