工作记录-----TOP K 小顶堆源码---小白也能看懂

本文链接：https://blog.csdn.net/qq_51711443/article/details/134994064

怎么实现小顶堆？

使用优先队列（PriorityQueue）来实现小顶堆

import java.util.PriorityQueue;

public class MinHeapExample {
    public static void main(String[] args) {
        // 创建一个小顶堆
        PriorityQueue<Integer> minHeap = new PriorityQueue<>();

        // 添加元素到小顶堆
        minHeap.add(5);
        minHeap.add(2);
        minHeap.add(8);
        minHeap.add(1);
        minHeap.add(10);

        // 获取小顶堆的堆顶元素（最小值）
        int minElement = minHeap.peek();
        System.out.println("最小元素：" + minElement);

        // 弹出并移除堆顶元素
        int removedElement = minHeap.poll();
        System.out.println("移除的最小元素：" + removedElement);

        // 输出小顶堆的元素（按照从小到大的顺序）
        System.out.println("小顶堆中的元素：");
        while (!minHeap.isEmpty()) {
            System.out.print(minHeap.poll() + " ");
        }
    }
}

这段代码会创建一个小顶堆，然后添加一些元素。你可以使用 peek() 方法来获取堆顶元素，使用 poll() 方法弹出并移除堆顶元素。最后，遍历小顶堆并输出元素，会按照从小到大的顺序输出。

当你需要找到数组或数据流中的前 K 个最小或最大的元素时，可以使用小顶堆（PriorityQueue）来解决。下面是一个用 Java 实现 TOP K 问题（找到数组中前 K 个最大元素）的示例代码：

import java.util.PriorityQueue;

public class TopKElements {
    public static void main(String[] args) {
        int[] nums = {3, 1, 5, 8, 2, 4};
        int k = 3; // 需要找到前 K 个最大元素

        int[] result = topK(nums, k);
        System.out.println("前 " + k + " 个最大元素为：");
        for (int num : result) {
            System.out.print(num + " ");
        }
    }

    public static int[] topK(int[] nums, int k) {
        // 创建一个小顶堆
        PriorityQueue<Integer> minHeap = new PriorityQueue<>();

        // 维护一个大小为 k 的小顶堆
        for (int num : nums) {
            minHeap.offer(num);
            if (minHeap.size() > k) {
                minHeap.poll(); // 如果堆的大小超过 k，弹出堆顶元素
            }
        }

        // 将堆中的元素放入结果数组中
        int[] result = new int[k];
        for (int i = k - 1; i >= 0; i--) {
            result[i] = minHeap.poll();
        }

        return result;
    }
}

这段代码会找到数组中前 K 个最大的元素，并将它们放入一个数组中返回。它利用了小顶堆的特性，每次将元素加入堆中，当堆的大小超过 K 时，弹出堆顶元素，最后将堆中的元素放入结果数组中。

在 Java 的 PriorityQueue 中，触发重新排序是在添加或删除元素时自动进行的。
当你使用 offer() 添加元素或者使用 poll() 或 remove() 移除元素时，如果对堆的结构造成了影响，PriorityQueue 会自动进行重新排序以保持堆的特性

在 PriorityQueue 内部，它使用了堆数据结构来维护元素的顺序。当添加或删除元素时，会调整堆的结构，将最小（或最大）的元素放置在堆顶

在 PriorityQueue 内部，怎么使用堆数据结构来维护元素的顺序？

PriorityQueue 在 Java 中使用堆数据结构来维护元素的顺序。具体来说，它使用了一个基于动态数组的完全二叉树（通常是数组）来表示堆。这个二叉树满足堆的性质：父节点的值始终小于或等于（最小堆）或者大于或等于（最大堆）其子节点的值。

在 PriorityQueue 中，这个二叉树通常是以数组的形式进行存储，数组的第一个元素（索引为 0）是堆顶元素。它的子节点可以通过一些简单的算法进行索引计算，例如，对于任意位置 i 的元素：

左子节点的索引为 2 * i + 1
右子节点的索引为 2 * i + 2
父节点的索引为 (i - 1) / 2

PriorityQueue 会根据元素的优先级将元素放置在正确的位置，并在需要时进行上述索引计算以保持堆的结构。这样做可以快速找到堆顶元素（最小或最大元素），并且在添加或删除元素时能够以较高的效率进行重新排序。

以下是一个示例，展示了如何使用数组表示堆的结构：

public class HeapExample {
    private int[] heap;      // 存储堆元素的数组
    private int size;        // 堆的当前大小
    private int capacity;    // 堆的容量

    public HeapExample(int capacity) {
        this.capacity = capacity;
        this.size = 0;
        this.heap = new int[capacity];
    }

//给定子节点的索引，返回其父节点的索引。
    private int getParentIndex(int childIndex) {
        return (childIndex - 1) / 2;
    }
//给定父节点的索引，返回其左子节点的索引。
    private int getLeftChildIndex(int parentIndex) {
        return 2 * parentIndex + 1;
    }
//给定父节点的索引，返回其右子节点的索引。
    private int getRightChildIndex(int parentIndex) {
        return 2 * parentIndex + 2;
    }
//hasParent：检查给定索引的元素是否有父节点。
    private boolean hasParent(int index) {
        return getParentIndex(index) >= 0;
    }
//hasLeftChild：检查给定索引的元素是否有左子节点。
    private boolean hasLeftChild(int index) {
        return getLeftChildIndex(index) < size;
    }
//hasRightChild：检查给定索引的元素是否有右子节点。
    private boolean hasRightChild(int index) {
        return getRightChildIndex(index) < size;
    }

    private void swap(int indexOne, int indexTwo) {
        int temp = heap[indexOne];
        heap[indexOne] = heap[indexTwo];
        heap[indexTwo] = temp;
    }
//如果堆已满，输出错误信息。否则，在堆的末尾插入新的元素，然后通过 heapifyUp 方法确保堆的结构保持正确。
    public void insert(int value) {
        if (size >= capacity) {
            System.out.println("Heap is full!");
            return;
        }
        heap[size] = value;
        size++;
        heapifyUp(size - 1);
    }
//这个方法在插入元素后，从插入位置开始，通过与父节点比较并交换的方式向上调整堆的结构，确保堆的性质不被破坏
    private void heapifyUp(int index) {
    //当前节点有父节点且当前节点的值小于其父节点的值。这意味着只要当前节点比其父节点小，就需要将它上移。
    //调用swap(index, getParentIndex(index))方法交换当前节点和其父节点的位置。这会将较小的值移到更高层级。
//将index更新为父节点的索引，以便继续向上检查。
        while (hasParent(index) && heap[index] < heap[getParentIndex(index)]) {
            swap(index, getParentIndex(index));
            index = getParentIndex(index);
        }
    }
    //删除堆顶元素（最小值）
public int removeMin() {
    if (size == 0) {
        throw new IllegalStateException("Heap is empty");
    }
    int minItem = heap[0];  // 保存最小值
    heap[0] = heap[size - 1];  // 将最后一个元素移到堆顶
    size--;  // 堆大小减小
    heapifyDown(0);  // 从堆顶开始进行向下堆化
    return minItem;  // 返回最小值
}
//removeMin()方法用于删除并返回堆中的最小值。
//首先，它检查堆是否为空。如果是空的，则抛出IllegalStateException异常。
//然后，它保存堆顶的最小值（即根节点）到变量minItem中。
//接下来，将最后一个元素移到堆顶位置，并将堆的大小减少1。
//最后，调用heapifyDown(0)方法从堆顶开始进行向下堆化操作，以确保新的根节点满足堆的性质。
//最终，返回保存的最小值。



//heapifyDown(int index)方法用于从给定索引开始向下进行堆化操作。
//首先，定义一个变量smallest来表示当前节点、左子节点和右子节点中值最小的索引，默认为给定索引。
//然后，获取左子节点和右子节点的索引。
//接着，在条件判断中找出左右子节点中较小的那个，并将其索引赋值给smallest。这样可以确定较小值所在位置。
//最后，如果较小子节点与当前节点不同，则交换它们，并递归调用heapifyDown()方法以继续向下对交换过后的子树进行堆化操作。
private void heapifyDown(int index) {
    int smallest = index;
    int left = getLeftChildIndex(index);
    int right = getRightChildIndex(index);

    // 找出左右子节点中较小的那个
    if (left < size && heap[left] < heap[smallest]) {
        smallest = left;
    }
    if (right < size && heap[right] < heap[smallest]) {
        smallest = right;
    }

    // 如果较小的子节点比当前节点小，则交换并递归进行堆化
    if (smallest != index) {
        swap(index, smallest);
        heapifyDown(smallest);
    }
}

}