优先队列的实现：基于最小堆的 Java 实现

优先队列是一种重要的数据结构，与普通队列不同，它每次从队列中取出的是具有最高优先级的元素。本文将介绍如何使用最小堆来实现优先队列，并提供详细的 Java 代码示例和解释。

什么是优先队列？

优先队列是一种抽象数据类型，其中每个元素都有一个与之相关的优先级。在删除操作中，总是删除具有最高优先级的元素（对于最小堆来说是最小值）。优先队列的典型应用包括任务调度、图算法（如 Dijkstra 算法）等。

为什么选择最小堆？

最小堆是一种完全二叉树，能够高效地进行插入和删除操作：

插入操作：时间复杂度为 (O(\log n))。
删除最小元素操作：时间复杂度为 (O(\log n))。

最小堆的这种高效性使其成为实现优先队列的理想选择。

构造树的选择：完全二叉树的数组表示

在实现最小堆时，我们有多种选择来构造树结构，但完全二叉树的数组表示方法是最为高效和适用的。以下是一些常见的树结构及其优缺点对比，说明我们为什么选择完全二叉树的数组表示。

实现方式 1：显式引用的树结构

Tree1A

public class Tree1A<Key> {Key k;Tree1A left;Tree1A middle;Tree1A right;...
}

优点：

结构清晰，容易理解。
方便直接操作每个节点和子节点。

缺点：

每个节点都需要存储多个引用（left, middle, right），占用额外内存。
遍历和查找操作的复杂度较高，尤其是对于非二叉树的情况。

Tree1B

public class Tree1B<Key> {Key k;Tree1B[] children;...
}

优点：

结构较为灵活，可以处理任意数量的子节点。

缺点：

需要为每个节点存储一个子节点数组，内存开销较大。
访问子节点时需要遍历数组，效率较低。

Tree1C

public class Tree1C<Key> {Key k;Tree1C favoredChild;Tree1C sibling;...
}

优点：

适用于偏斜树（如二叉堆），可以优化特定树结构的存储。

缺点：

代码复杂度较高，尤其是在处理兄弟节点关系时。
内存开销较大，需要存储额外的指针。

实现方式 2：父数组和键数组

public class Tree2<Key> {Key[] keys;int[] parents;...
}

优点：

只需两个数组，存储效率高。
可以直接通过数组索引访问父节点和子节点，访问效率高。

缺点：

需要额外的父数组来存储父节点索引。
对于完全二叉树，这种表示有些冗余，因为完全二叉树可以直接通过索引计算父子关系。

实现方式 3：完全二叉树的数组表示

public class TreeC<Key> {Key[] keys;...
}

优点：

存储效率最高，只需要一个数组，没有额外的指针或索引开销。
通过简单的索引计算（例如，对于节点i，其左子节点为2i+1，右子节点为2i+2）可以高效访问节点。

缺点：

适用于完全二叉树，对于不完全二叉树，需要处理“间隙”问题。
不适合表示非完全二叉树或其他非规则树结构。

结论

对于堆这种完全二叉树结构，用于优先队列的实现时，**实现方式 3（完全二叉树的数组表示）**是最优选择。

理由如下：

存储效率：只需要一个数组来存储节点，无需额外存储指针或索引。
访问效率：通过索引计算可以高效访问父节点和子节点。
代码简单性：实现和维护简单，不需要复杂的指针操作。

在实现优先队列时，由于堆的性质决定了其是一个完全二叉树，完全二叉树的数组表示方式最为高效和简单，因此是最佳选择。

最小堆优先队列的实现

我们将用数组实现一个最小堆，以下是关键方法的详细解释和代码。

1. 数据结构

首先，我们定义了一个泛型类 MinHeapPriorityQueue，用来存储我们的最小堆：

import java.util.NoSuchElementException;public class MinHeapPriorityQueue<Key extends Comparable<Key>> {private Key[] keys; // 用于存储堆元素的数组private int size; // 当前堆中的元素数量// 构造函数，初始化优先队列，指定初始容量public MinHeapPriorityQueue(int capacity) {keys = (Key[]) new Comparable[capacity];size = 0;}// 检查堆是否为空public boolean isEmpty() {return size == 0;}// 返回堆中的元素数量public int size() {return size;}// 返回节点 k 的父节点索引private int parent(int k) {return (k - 1) / 2;}// 返回节点 k 的左子节点索引private int leftChild(int k) {return 2 * k + 1;}// 返回节点 k 的右子节点索引private int rightChild(int k) {return 2 * k + 2;}// 交换索引 i 和 j 处的元素private void swap(int i, int j) {Key temp = keys[i];keys[i] = keys[j];keys[j] = temp;}

2. 核心操作：swim 和 sink

swim 方法用于在插入元素时维护堆的性质，通过将新插入的元素上浮到适当位置：

    // 上浮操作，用于维持堆的性质private void swim(int k) {while (k > 0 && keys[parent(k)].compareTo(keys[k]) > 0) {swap(k, parent(k));k = parent(k);}}

sink 方法用于在删除最小元素时维护堆的性质，通过将替换到根位置的元素下沉到适当位置：

    // 下沉操作，用于维持堆的性质private void sink(int k) {while (leftChild(k) < size) {int j = leftChild(k);if (j < size - 1 && keys[j].compareTo(keys[j + 1]) > 0) {j++;}if (keys[k].compareTo(keys[j]) <= 0) {break;}swap(k, j);k = j;}}

3. 添加和删除操作

add 方法用于向优先队列添加新元素：

    // 向堆中添加新元素public void add(Key key) {if (size == keys.length) {resize(2 * keys.length);}keys[size] = key;swim(size);size++;}

getSmallest 方法用于获取堆顶元素，即最小元素：

    // 获取堆顶元素（最小元素）public Key getSmallest() {if (isEmpty()) {throw new NoSuchElementException("Priority queue underflow");}return keys[0];}

removeSmallest 方法用于删除并返回堆顶元素：

    // 删除并返回堆顶元素（最小元素）public Key removeSmallest() {if (isEmpty()) {throw new NoSuchElementException("Priority queue underflow");}Key min = keys[0];swap(0, size - 1);size--;sink(0);keys[size] = null; // 避免对象游离if (size > 0 && size == keys.length / 4) {resize(keys.length / 2);}return min;}

4. 扩容和缩容

为了确保数组具有足够的空间存储新元素，当数组已满时需要扩容，当数组元素较少时进行缩容：

    // 调整数组容量private void resize(int capacity) {Key[] temp = (Key[]) new Comparable[capacity];for (int i = 0; i < size; i++) {temp[i] = keys[i];}keys = temp;}
}