剖析数据结构中的堆(Heap)：结构原理与Java实现

后端

2023-09-30 08:34:15

1. 堆（Heap）概览

在计算机科学中，堆（Heap）是一种重要的数据结构。堆是一种特殊的二叉树，它满足以下性质：

它是一棵完全二叉树，即除了最后一层外，所有层的结点都有两个子结点；
每个结点的值都大于或等于其左右子结点的值，称为大顶堆（Max Heap）；
每个结点的值都小于或等于其左右子结点的值，称为小顶堆（Min Heap）。

2. 堆的种类

根据堆中结点值的大小比较方式，堆分为大顶堆和小顶堆两种：

大顶堆：堆中每个结点的值都大于或等于其左右子结点的值。在这种堆中，根结点是最大值。
小顶堆：堆中每个结点的值都小于或等于其左右子结点的值。在这种堆中，根结点是最小值。

3. 堆的应用

堆在计算机科学中有着广泛的应用，包括：

优先级队列：堆可以作为一种优先级队列，可以根据结点的值来确定优先级。
排序：堆可以用来对数据进行排序。堆排序是一种常用的排序算法，它可以在O(nlogn)的时间内完成排序。
哈夫曼编码：堆可以用来生成哈夫曼编码。哈夫曼编码是一种无损数据压缩算法，它可以将数据压缩到尽可能小的尺寸。

4. Java代码实现

以下是用Java实现的堆的代码：

import java.util.ArrayList;
import java.util.Comparator;

public class Heap<T> {

    private ArrayList<T> data;
    private Comparator<T> comparator;

    public Heap() {
        this(null);
    }

    public Heap(Comparator<T> comparator) {
        this.data = new ArrayList<>();
        this.comparator = comparator;
    }

    public void add(T value) {
        data.add(value);
        upHeap(data.size() - 1);
    }

    public T remove() {
        if (data.isEmpty()) {
            return null;
        }
        T value = data.get(0);
        data.set(0, data.get(data.size() - 1));
        data.remove(data.size() - 1);
        downHeap(0);
        return value;
    }

    public T peek() {
        if (data.isEmpty()) {
            return null;
        }
        return data.get(0);
    }

    private void upHeap(int index) {
        while (index > 0) {
            int parentIndex = (index - 1) / 2;
            if (comparator.compare(data.get(index), data.get(parentIndex)) > 0) {
                swap(index, parentIndex);
                index = parentIndex;
            } else {
                break;
            }
        }
    }

    private void downHeap(int index) {
        while (true) {
            int leftChildIndex = 2 * index + 1;
            int rightChildIndex = 2 * index + 2;
            int largestIndex = index;
            if (leftChildIndex < data.size() && comparator.compare(data.get(leftChildIndex), data.get(largestIndex)) > 0) {
                largestIndex = leftChildIndex;
            }
            if (rightChildIndex < data.size() && comparator.compare(data.get(rightChildIndex), data.get(largestIndex)) > 0) {
                largestIndex = rightChildIndex;
            }
            if (largestIndex != index) {
                swap(index, largestIndex);
                index = largestIndex;
            } else {
                break;
            }
        }
    }

    private void swap(int index1, int index2) {
        T temp = data.get(index1);
        data.set(index1, data.get(index2));
        data.set(index2, temp);
    }

    public static void main(String[] args) {
        Heap<Integer> heap = new Heap<>(Comparator.comparingInt(Integer::intValue));
        heap.add(10);
        heap.add(5);
        heap.add(15);
        heap.add(3);
        heap.add(7);
        heap.add(1);

        while (!heap.isEmpty()) {
            System.out.println(heap.remove());
        }
    }
}