二叉树实战（六） - 堆（完全二叉树）的实现

区别于之前我们实现的基于链表实现的二叉查找树，堆是完全二叉树的数组对象。

堆的特性：

1. 它是完全二叉树，除了树的最后一层结点是不需要是满的，其他的每一层从左往右都是满的，如果最后一层结点不是满的，那么要求左满右不满。

2. 它通常用数组实现，其结构如下图：

 

如果一个结点的位置为k，则它的父节点的位置为[k/2]，而它的两个子节点的位置分别为2k和2k+1。这样，在不使用指针的情况下，我们也可以通过计算数组的索引在树中上下移动。从a[k]向上一层，就令k等于k/2，向下一层就令k等于2k或2k+1。

3.每个结点都大于等于它的两个子结点。这里要注意的是堆中仅仅规定了每个结点大于它的两个子结点，但这两个子结点的顺序并没有做规定，跟我们之前学习的二叉查找树是有区别的。

public class Heap<T extends Comparable<T>> {

    public static void main(String[] args) {
        // 创建堆对象
        Heap<String> heap = new Heap<>(10);
        // 往堆中存入字符串数据
        heap.insert("A");
        heap.insert("B");
        heap.insert("C");
        heap.insert("D");
        heap.insert("E");
        heap.insert("F");
        heap.insert("G");
        // 通过循环从堆中删除数据
        String result = null;
        while ((result = heap.delMax()) != null) {
            System.out.print(result + " ");
        }
    }


    // 存储堆中的元素
    private T[] items;
    // 记录堆中的元素
    private int N;

    // 构造方法
    public Heap(int capacity) {
        this.items = (T[]) new Comparable[capacity + 1];
        this.N = 0;
    }

    // 判断堆中索引i处的元素是否小于索引j处的元素
    private boolean less(int i, int j) {
        return items[i].compareTo(items[j]) < 0;
    }

    // 交换堆中索引i和索引j处的值
    private void exch(int i, int j) {
        T temp = items[i];
        items[i] = items[j];
        items[j] = temp;
    }

    // 往堆中插入一个元素
    public void insert(T t) {
        // 插入元素
        items[++N] = t;
        // 上浮，使其在正确的位置
        swim(N);
    }

    // 使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
    private void swim(int k) {
        // 通过循环不断比较当前结点和其父节点的值，如果发现父节点的值比当前结点的值小，则交换位置
        while (k > 1) {
            // 比较当前结点和其父节点
            if (less(k / 2, k)) {
                exch(k / 2, k);
            }
            k = k / 2;
        }
    }

    // 删除堆中的最大元素，并返回这个最大元素
    public T delMax() {
        T max = items[1];
        // 交换索引1处的元素和最大索引处的元素，让完全二叉树中的最右侧的元素变为临时根结点
        exch(1, N);
        // 最大索引处的元素删除掉
        items[N] = null;
        // 元素个数-1
        N--;
        // 通过下沉调整，让堆重新排序，保证有序
        sink(1);
        return max;
    }

    // 使用下沉算法，使索引K处的元素能在堆中处于一个正确的位置
    private void sink(int k) {
        while (2 * k <= N) {
            // 获取当前结点的子结点的较大结点
            int max; // 记录较大结点所在的索引
            if (2 * k + 1 < N) {
                if (less(2 * k, 2 * k + 1)) {
                    max = 2 * k + 1;
                } else {
                    max = 2 * k;
                }
            } else {
                max = 2 * k;
            }
            // 比较当前结点和较大结点的值
            if (!less(k, max)) {
                // 不下沉，结束下沉操作
                break;
            } else {
                // 下沉
                exch(k, max);
            }
            k = max;
        }
    }

}