数据结构与算法（Java）——堆

1、堆的定义

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

堆的特性：

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

2、堆的API设计

类名	Heap
构造方法	Heap(int capacity)：创建容量为capacity的Heap对象
成员方法	1.private boolean less(int i,int j)：判断堆中索引i处的元素是否小于索引j处的元素 2.private void exch(int i,int j):交换堆中i索引和j索引处的值 3.public T delMax():删除堆中最大的元素,并返回这个最大元素 4.public void insert(T t)：往堆中插入一个元素 5.private void swim(int k):使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置 6.private void sink(int k):使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置
成员变量	1.private T[] imtes : 用来存储元素的数组 2.private int N：记录堆中元素的个数

3、堆的实现代码

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

    public Heap(int capacity) {
        this.datas = (T[]) new Comparable[capacity + 1];
        this.N = 0;
    }

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

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

    //往堆中插入一个元素
    public void insert(T t) {
        datas[++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 = datas[1];

        //交换索引1处的元素与最大索引处的元素，让完全二叉树中最右侧的元素变为临时根节点
        exch(1, N);
        //最大索引处的元素删除掉
        datas[N] = null;
        //元素个数减1
        N--;
        //通过下沉排序，让堆重新有序
        sink(1);
        return max;
    }

    //使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置
    private void sink(int k) {
        //对比当前结点k和其子结点Max(2k，2k+1)
        //如果当前结点小,则交换位置
        while (2 * k <= N) {
            //获取当前结点的子结点的较大结点
            int max;
            if (2 * k + 1 <= N) {

                max = less(2 * k, 2 * k + 1) ? 2 * k + 1 : 2 * k;


            } else {
                max = 2 * k;
            }

            //比较当前结点的子结点中的较大值
            if (!less(k, max)) {
                break;
            }

            //交换k索引处的值和max索引的值
            exch(k, max);

            //变换k的值
            k = max;
        }
    }
}

代码测试运行结果

4、堆排序

堆排序（大根堆）的核心是上浮算法和下沉算法，两个原理都一样

上浮：最后面的结点一直与父结点比较，如果比父结点大，就交换。

下沉：第一个结点一直与 2个子结点中较大的子结点 比较，如果小于较大的子结点，就交换。

public class HeapSort<T extends Comparable<T>> {
	
    //对source数组中的数据从小到大排序
    public static void sort(Comparable[] source) {
        //构建堆
        Comparable[] heap = new Comparable[source.length + 1];
        createHeap(source, heap);

        //定义一个变量，记录未排序的元素中最大的索引
        int N = heap.length - 1;
        //循环，交换索引1处的元素和排序的元素中最大索引处的元素
        while (N != 1) {
            //交换元素
            exch(heap, 1, N);
            //排除交换后最大元素所在的索引，让它不参与堆的下沉调整
            N--;
            //需要索引1处的元素进行堆的下沉调整
            sink(heap, 1, N);
        }

        //把heap中的数据复制到原数组source中
        System.arraycopy(heap, 1, source, 0, source.length);
    }

    //根据原数组source，构造出堆heap
    private static void createHeap(Comparable[] source, Comparable[] heap) {
        //吧source中的元素拷贝到heap中，heap中的元素就形成一个无序的堆
        System.arraycopy(source, 0, heap, 1, source.length);

        //对堆中的元素做下沉调整（从长度的一半处开始，往索引1处扫描）
        int l = heap.length;

        for (int i = l / 2; i > 0; i--) {
            sink(heap, i, l - 1);
        }
    }

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

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

    //在heap堆中，对target处的元素做下沉，范围是0-range
    private static void sink(Comparable[] heap, int target, int range) {
        while (2 * target <= range) {
            //找出当前结点的较大的结点
            int max;
            if (2 * target + 1 <= range) {
                //如果有2个子结点，取其中较大的
                max = less(heap, 2 * target, 2 * target + 1) ? 2 * target + 1 : 2 * target;
            } else {
                //如果只有1个子结点
                max = 2 * target;
            }

            //比较当前结点的值和较大子结点的值,如果当前结点的值大于子结点的值就结束循环
            if (!less(heap, target, max))
                break;

            exch(heap, target, max);

            target = max;
        }
    }
}