堆-java语言版

堆是计算机科学中一类特殊的数据结构的统称，堆通常可以被看做是一棵完全二叉树的数组对象。

-- 堆的特性：

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

2.它通常用数组来实现。 具体方法就是将二叉树的结点按照层级顺序放入数组中，根结点在位置1，它的子结点在位置2和3，而子结点的子 结点则分别在位置4,5,6和7，以此类推。

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

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

-- API设计：

-- 代码：

/**
 * 堆
 */
public class Heap<T extends Comparable<T>> {
    // 存储堆中的元素
    private T[] items;
    // 记录堆中元素的个数
    private int N;

    // 构造方法
    public Heap(int capacity) {
        items = (T[]) new Comparable[capacity+1];
        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 = k / 2;
        }
    }
    // 删除堆中最大的元素，并返回这个最大值
    public T delMax() {
        T max = items[1];
        // 交换索引1处和所以N处的值
        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;
            }
            // 当前结点小，则交换
            exch(k,max);
            // 更新k位置的索引
            k = max;
        }
    }
}

-- 测试代码：

public class HeapTest {
    public static void main(String[] args) throws Exception {
        Heap<String> heap = new Heap<String>(20);
        heap.insert("S");
        heap.insert("G");
        heap.insert("I");
        heap.insert("E");
        heap.insert("N");
        heap.insert("H");
        heap.insert("O");
        heap.insert("A");
        heap.insert("T");
        heap.insert("P");
        heap.insert("R");
        String del;
        while ((del = heap.delMax()) != null) {
            System.out.print(del + ",");
        }
    }
}

-- 运行效果图：

@ 以上内容属于个人笔记