黑虾电影1. 理解堆结构与PriorityQueue
在计算机科学中，堆(Heap)是一种特殊的完全二叉树结构，它满足堆属性：每个节点的值都大于等于或小于等于其子节点的值。根据这个属性，堆可以分为两种基本类型：
- 最大堆(Max Heap)：每个父节点的值都大于或等于其子节点的值，根节点是整个堆中的最大值
- 最小堆(Min Heap)：每个父节点的值都小于或等于其子节点的值，根节点是整个堆中的最小值
Java中的PriorityQueue类是基于优先级堆的无界优先级队列。这个队列中的元素可以按照它们的自然顺序排序，也可以通过构造时提供的Comparator进行排序。PriorityQueue不允许null元素，也不允许插入不可比较的对象。
PriorityQueue的内部实现是一个平衡的二叉堆：队列的头是基于自然排序或者Comparator排序的最小元素。当有多个相同优先级的元素时，队列的头是这些元素中的一个，选择是任意的。
注意：虽然PriorityQueue被称为队列，但它的行为与传统的FIFO(先进先出)队列不同。它是按照元素的优先级来决定出队顺序的。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. PriorityQueue的基本使用
2.1 创建PriorityQueue
PriorityQueue提供了几个构造函数，最常用的有：
java复制// 创建一个默认容量(11)的PriorityQueue，按照元素的自然顺序排序
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
// 创建一个指定初始容量的PriorityQueue
PriorityQueue<Integer> minHeapWithCapacity = new PriorityQueue<>(100);
// 创建一个使用自定义比较器的PriorityQueue
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
2.2 添加和移除元素
PriorityQueue提供了标准的队列操作方法：
java复制PriorityQueue<Integer> heap = new PriorityQueue<>();
// 添加元素
heap.add(5); // 或 heap.offer(5)
heap.add(3);
heap.add(7);
// 查看堆顶元素(不移除)
int top = heap.peek(); // 返回3
// 移除并返回堆顶元素
int first = heap.poll(); // 返回3
2.3 自定义比较器
PriorityQueue的强大之处在于可以使用自定义的比较逻辑。例如，如果我们有一个Person类：
java复制class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
// 按年龄排序的PriorityQueue
PriorityQueue<Person> ageQueue = new PriorityQueue<>(Comparator.comparingInt(p -> p.age));
// 按姓名排序的PriorityQueue
PriorityQueue<Person> nameQueue = new PriorityQueue<>(Comparator.comparing(p -> p.name));
3. 使用PriorityQueue解决TOPK问题
TOPK问题是指从一个数据集中找出最大或最小的K个元素。使用堆结构可以高效地解决这类问题，时间复杂度为O(n log k)，其中n是数据集大小，k是要找的元素数量。
3.1 找最大的K个元素（最小堆方法）
要找出最大的K个元素，我们可以维护一个大小为K的最小堆：
- 初始化一个大小为K的最小堆
- 遍历所有元素：
- 如果堆的大小小于K，直接添加当前元素
- 否则，比较当前元素与堆顶元素：
- 如果当前元素大于堆顶元素，移除堆顶元素并添加当前元素
- 否则跳过
- 最后堆中剩下的就是最大的K个元素
java复制public static List<Integer> topKLargest(int[] nums, int k) {
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
for (int num : nums) {
if (minHeap.size() < k) {
minHeap.offer(num);
} else if (num > minHeap.peek()) {
minHeap.poll();
minHeap.offer(num);
}
}
return new ArrayList<>(minHeap);
}
3.2 找最小的K个元素（最大堆方法）
类似地，要找出最小的K个元素，我们可以维护一个大小为K的最大堆：
- 初始化一个大小为K的最大堆
- 遍历所有元素：
- 如果堆的大小小于K，直接添加当前元素
- 否则，比较当前元素与堆顶元素：
- 如果当前元素小于堆顶元素，移除堆顶元素并添加当前元素
- 否则跳过
- 最后堆中剩下的就是最小的K个元素
java复制public static List<Integer> topKSmallest(int[] nums, int k) {
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
for (int num : nums) {
if (maxHeap.size() < k) {
maxHeap.offer(num);
} else if (num < maxHeap.peek()) {
maxHeap.poll();
maxHeap.offer(num);
}
}
return new ArrayList<>(maxHeap);
}
3.3 时间复杂度分析
使用堆解决TOPK问题的时间复杂度为O(n log k)，其中：
- n是输入数组的大小
- k是要找的元素数量
- log k是每次堆操作的时间复杂度
这种方法比完全排序后再取前K个元素(O(n log n))更高效，特别是当k远小于n时。
4. 实际应用案例
4.1 实时统计高频词汇
假设我们正在开发一个系统，需要实时统计文本中出现频率最高的K个词汇：
java复制public static List<String> topKFrequentWords(String[] words, int k) {
// 统计词频
Map<String, Integer> frequencyMap = new HashMap<>();
for (String word : words) {
frequencyMap.put(word, frequencyMap.getOrDefault(word, 0) + 1);
}
// 使用最小堆，按频率排序
PriorityQueue<Map.Entry<String, Integer>> heap = new PriorityQueue<>(
(a, b) -> a.getValue().equals(b.getValue()) ?
b.getKey().compareTo(a.getKey()) :
a.getValue() - b.getValue()
);
// 维护大小为K的堆
for (Map.Entry<String, Integer> entry : frequencyMap.entrySet()) {
heap.offer(entry);
if (heap.size() > k) {
heap.poll();
}
}
// 收集结果
List<String> result = new ArrayList<>();
while (!heap.isEmpty()) {
result.add(heap.poll().getKey());
}
Collections.reverse(result);
return result;
}
4.2 股票交易系统中的实时TopK价格
在金融系统中，我们可能需要实时监控最高或最低的K个价格：
java复制class StockPriceMonitor {
private final PriorityQueue<Double> minHeap; // 存储最高的K个价格
private final PriorityQueue<Double> maxHeap; // 存储最低的K个价格
private final int k;
public StockPriceMonitor(int k) {
this.k = k;
this.minHeap = new PriorityQueue<>();
this.maxHeap = new PriorityQueue<>(Collections.reverseOrder());
}
public void addPrice(double price) {
// 处理最高价格
if (minHeap.size() < k) {
minHeap.offer(price);
} else if (price > minHeap.peek()) {
minHeap.poll();
minHeap.offer(price);
}
// 处理最低价格
if (maxHeap.size() < k) {
maxHeap.offer(price);
} else if (price < maxHeap.peek()) {
maxHeap.poll();
maxHeap.offer(price);
}
}
public List<Double> getTopPrices() {
return new ArrayList<>(minHeap);
}
public List<Double> getBottomPrices() {
return new ArrayList<>(maxHeap);
}
}
5. 性能优化与注意事项
5.1 初始化容量
如果预先知道数据量的大小，可以在创建PriorityQueue时指定初始容量，避免频繁扩容：
java复制// 假设我们知道大约有10000个元素，K=100
PriorityQueue<Integer> heap = new PriorityQueue<>(100);
5.2 对象比较的注意事项
当使用自定义对象时，必须确保比较逻辑是一致的：
java复制class Student implements Comparable<Student> {
String name;
int score;
@Override
public int compareTo(Student other) {
return Integer.compare(this.score, other.score);
}
// 必须同时重写equals和hashCode方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Student)) return false;
Student student = (Student) o;
return score == student.score &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, score);
}
}
重要：如果两个对象在compareTo方法中相等，它们也应该在equals方法中相等，否则可能导致PriorityQueue行为不一致。
5.3 多线程环境下的使用
PriorityQueue不是线程安全的。在多线程环境下，应该使用线程安全的替代品：
java复制// 使用PriorityBlockingQueue替代
PriorityBlockingQueue<Integer> threadSafeQueue = new PriorityBlockingQueue<>();
或者使用外部同步：
java复制PriorityQueue<Integer> queue = new PriorityQueue<>();
// 在访问队列时同步
synchronized(queue) {
queue.add(1);
// 其他操作
}
5.4 内存使用考虑
对于非常大的数据集，维护一个大小为K的堆比维护整个数据集的排序结构更节省内存。例如，从10亿个元素中找出前100个，只需要维护一个100个元素的堆，而不是对整个10亿个元素进行排序。
6. 与其他方法的比较
6.1 与完全排序比较
完全排序后再取前K个元素：
java复制Arrays.sort(nums);
// 取前K个或后K个
- 时间复杂度：O(n log n)
- 空间复杂度：O(n) (如果原地排序则为O(1))
- 优点：实现简单
- 缺点：当K远小于n时效率低
6.2 与快速选择算法比较
快速选择(Quickselect)是快速排序的变种，可以在平均O(n)时间内找到第K个元素：
- 时间复杂度：平均O(n)，最坏O(n^2)
- 空间复杂度：O(1) (原地分区)
- 优点：平均情况下比堆方法更快
- 缺点：实现复杂，最坏情况性能差
6.3 何时选择堆方法
堆方法在以下情况下特别适用：
- 需要处理的数据是流式的，无法一次性获取所有数据
- 内存有限，无法存储整个数据集
- K远小于n，且需要稳定的时间复杂度
- 需要动态维护TopK列表（随时添加新元素）
7. 高级应用：处理流式数据
堆方法特别适合处理流式数据，因为我们无法一次性获取所有数据：
java复制class StreamTopK {
private final PriorityQueue<Integer> minHeap;
private final int k;
public StreamTopK(int k) {
this.k = k;
this.minHeap = new PriorityQueue<>();
}
public void add(int num) {
if (minHeap.size() < k) {
minHeap.offer(num);
} else if (num > minHeap.peek()) {
minHeap.poll();
minHeap.offer(num);
}
}
public List<Integer> getTopK() {
return new ArrayList<>(minHeap);
}
}
// 使用示例
StreamTopK processor = new StreamTopK(10);
// 模拟流式数据
for (int i = 0; i < 1000000; i++) {
int randomNum = (int) (Math.random() * 1000000);
processor.add(randomNum);
}
List<Integer> top10 = processor.getTopK();
这种方法的优势在于：
- 只需要O(k)的内存空间
- 每个新元素处理时间为O(log k)
- 可以无限处理数据流
8. 常见问题与解决方案
8.1 堆大小不固定
有时我们需要维护一个动态大小的堆，而不是固定的K。例如，我们可能想保留所有大于某个阈值的元素：
java复制PriorityQueue<Integer> heap = new PriorityQueue<>();
int threshold = 100;
// 添加元素时
if (num > threshold) {
heap.offer(num);
} else {
// 可能需要调整threshold并重新筛选堆
}
8.2 处理重复元素
默认情况下，PriorityQueue允许重复元素。如果需要去重，可以考虑以下方法：
java复制// 方法1：使用Set去重后再处理
Set<Integer> uniqueNumbers = new HashSet<>(Arrays.asList(nums));
PriorityQueue<Integer> heap = new PriorityQueue<>(uniqueNumbers);
// 方法2：在比较器中考虑更多属性
class Item {
int id;
int value;
// 比较时同时考虑id和value
}
PriorityQueue<Item> heap = new PriorityQueue<>(
Comparator.comparingInt((Item item) -> item.value)
.thenComparingInt(item -> item.id)
);
8.3 性能调优
对于极端性能要求的场景，可以考虑：
- 使用原生数组实现的堆（减少对象开销）
- 使用更高效的比较器（避免频繁的对象方法调用）
- 批量操作（如果可能）
- 考虑使用更专门的数结构（如斐波那契堆）
9. 扩展应用：多条件排序的TOPK
有时我们需要基于多个条件来选择TopK元素。例如，选择分数最高但年龄最小的学生：
java复制class Student {
String name;
int score;
int age;
}
PriorityQueue<Student> heap = new PriorityQueue<>(
Comparator.comparingInt(Student::getScore)
.reversed()
.thenComparingInt(Student::getAge)
);
// 添加学生到堆中...
// 维护堆大小为K...
这种多条件排序在实际应用中非常常见，如电商中的商品排序（销量+评分+价格等）。
10. 实际项目中的经验分享
在实际项目中使用PriorityQueue解决TOPK问题时，我积累了一些有价值的经验：
-
监控堆大小：在生产环境中，应该监控堆的实际大小，确保它不会因为异常数据而膨胀。我曾经遇到过一个案例，由于比较器实现错误，导致所有元素都被认为"相等"，结果堆大小远超过预期的K值。
-
处理空值：PriorityQueue不允许null元素，但实际数据中可能有null。预处理步骤中应该过滤或转换这些值：
java复制dataStream.filter(Objects::nonNull).forEach(processor::add);
-
内存敏感环境：在内存受限的环境（如Android应用）中，即使是K很小的堆也可能成为问题。可以考虑：
- 使用更紧凑的数据结构
- 定期清理堆
- 使用弱引用或其他内存优化技术
-
测试边界条件：特别注意测试以下情况：
- K=0或K=1
- K等于或大于输入大小
- 所有元素相同
- 输入包含极值（如Integer.MAX_VALUE）
-
日志记录：在调试时，记录堆的变化过程非常有帮助。可以创建一个装饰器类来记录操作：
java复制class LoggingHeap<T> {
private final PriorityQueue<T> heap;
public void add(T item) {
System.out.println("Adding: " + item);
heap.add(item);
System.out.println("Heap state: " + heap);
}
// 其他方法...
}
- 考虑并行处理：对于非常大的数据集，可以考虑并行处理：
- 将数据分片
- 每个分片计算局部TopK
- 合并局部结果得到全局TopK
这种方法可以显著提高处理速度，特别是在多核系统上。