Java实现堆算法的使用示例

public class MaxHeap<T extends Comparable<T>> {
    private T[] heap; // 堆元素数组
    private int size; // 堆元素数量

    @SuppressWarnings("unchecked")
    public MaxHeap(int capacity) {
        heap = (T[]) new Comparable[capacity + 1]; // 数组下标从1开始
        size = 0;
    }

    public void insert(T value) {
        if (size == heap.length - 1) {
            resize();
        }

        heap[++size] = value; // 新元素插入到数组最后
        swim(size); // 上滤操作
    }

    public T deleteMax() {
        if (size == 0) {
            throw new NoSuchElementException();
        }

        T max = heap[1]; // 堆顶元素
        heap[1] = heap[size--]; // 将数组最后一个元素替换到堆顶
        sink(1); // 下滤操作
        heap[size + 1] = null; // 释放旧的堆顶元素

        return max;
    }

    public T getMax() {
        if (size == 0) {
            throw new NoSuchElementException();
        }

        return heap[1];
    }

    public void heapSort(T[] arr) {
        heapify(arr); // 初始化堆
        for (int i = size; i > 0; i--) {
            arr[i - 1] = deleteMax(); // 依次取出堆顶元素
        }
    }

    private void swim(int k) {
        while (k > 1 && heap[k].compareTo(heap[k / 2]) > 0) { // 父节点小于当前节点，上滤
            swap(k, k / 2);
            k /= 2; // 移动到父节点
        }
    }

    private void sink(int k) {
        while (2 * k <= size) { // 如果有左孩子
            int j = 2 * k;
            if (j < size && heap[j].compareTo(heap[j + 1]) < 0) { // 选择左右孩子中较大的那个
                j++;
            }

            if (heap[k].compareTo(heap[j]) >= 0) { // 如果父节点不小于孩子节点，下滤结束
                break;
            }

            swap(k, j); // 父节点和子节点交换
            k = j; // 移动到子节点
        }
    }

    private void heapify(T[] arr) {
        heap = (T[]) new Comparable[arr.length + 1];
        size = arr.length;

        System.arraycopy(arr, 0, heap, 1, arr.length); // 复制数组元素到堆中

        for (int i = size / 2; i >= 1; i--) { // 倒序下滤，从最后一个非叶子节点开始
            sink(i); // 下滤操作
        }
    }

    private void resize() {
        int newSize = heap.length * 2;
        heap = Arrays.copyOf(heap, newSize);
    }

    private void swap(int i, int j) {
        T temp = heap[i];
        heap[i] = heap[j];
        heap[j] = temp;
    }
}

MaxHeap<Integer> maxHeap = new MaxHeap<>(10);
maxHeap.insert(3);
maxHeap.insert(1);
maxHeap.insert(4);
maxHeap.insert(1);
maxHeap.insert(5);
System.out.println(maxHeap.deleteMax()); // 输出：5
System.out.println(maxHeap.getMax()); // 输出：4

Integer[] arr = {3, 1, 4, 1, 5};
maxHeap.heapSort(arr);
System.out.println(Arrays.toString(arr)); // 输出：[1, 1, 3, 4, 5]