数据结构之堆

堆常用来实现优先队列，在这种队列中，待删除的元素为优先级最高（最低）的那个。在任何时候，任意优先元素都是可以插入到队列中去的，是计算机科学中一类特殊的数据结构的统称。

一、堆的定义：

如果有一个关键码的集合K={k0，k1，k2，…kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储
在一个一维数组中，并满足:Ki<=K2i+1且Ki<=K2i+2(Ki>=K2i+1且Ki>=K2i+2) i =0，1，2…则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

堆的性质:
●堆中某个节点的值总是不大于或不小于其父节点的值;·堆总是一棵完全二叉树。

如下图，图一为大根堆，图二为小根堆。

二、堆的存储

从堆的概念可知，堆是一棵完全二叉树，因此可以层序的规则采用顺序的方式来高效存储。

注意:对于非完全二叉树，则不适合使用顺序方式进行存储，因为为了能够还原二叉树，空间中必须要存储空节点，就会导致空间利用率比较低。

将元素存储到数组中后，可以根据二叉树章节的性质5对树进行还原。假设i为节点在数组中的下标，则有:

• 如果i为0，则i表示的节点为根节点，否则i节点的双亲节点为(i -1)/2；
• 如果2i+1小于节点个数，则节点的左孩子下标为2i+1，否则没有左孩子；
• 如果2i+2小于节点个数，则节点i的右孩子下标为2i+2，否则没有右孩子。

三、支持的基本操作

堆支持以下的基本操作:

• creat:建立一个空堆;
• offer:向堆中插入一个新元素;
• peek:获取当前堆顶元素的值;
• poll:删除堆顶元素。

堆的两种调整方式：

• 向下调整
• 向上调整

四、自定义实现堆的基本操作

1、向下调整：
（1）前提:当前节点的左右子树，都是符合堆的要求，只有根节点不符合。这个时候就可以针对根节点开始进行向下调整了。
（2）方法：以大堆为例

• 先找到左右子树中较大的值；
• 拿着较大的值和根节点进行比较判定是否符合堆的要求；如果不符合，就交换这两个元素；
• 交换完毕之后，再针对对应的子树继续进行向下调整，直到整个树都符合堆的规则为止。

 // array 表示用来存储堆的数组.
    // size 表示数组上有效元素的个数(有效元素不一定和 array.length 一样)
    // index 表示从哪个位置开始进行向下调整
    // 以大堆为例
    public static void shiftDown(int[] array, int size, int index) {
        int parent = index;
        int child = 2 * parent + 1;
        // 循环条件的含义:
        // 如果 child < size, 就意味着 child 是存在的.
        // 如果 child >= size, 就说明 parent 已经是叶子节点.
        while (child < size) {
            // 第一次比较, 找出左右子树的最大值.
            if (child + 1 < size && array[child + 1] > array[child]) {
                // 如果发现右子树存在, 且右子树比左子树大,
                // 就让 child 指向 右子树
                child = child + 1;
            }
            // 希望这个条件结束之后, 无论如何 child 都指向左右子树中较大的那个
            // 第二次比较, 拿刚才的 child 位置的元素和 parent 进行比较
            // 看是否符合堆的要求. 如果不符合就交换两个元素
            if (array[parent] < array[child]) {
                // 不符合大堆要求
                int tmp = array[parent];
                array[parent] = array[child];
                array[child] = tmp;
            } else {
                // 调整就完成了, 刚才index位置的节点已经被放到合适的位置了
                // 不需要继续调整了
                break;
            }
            // 更新循环变量
            parent = child;
            child = 2 * parent + 1;
        }
    }

2、向上调整：
与向下调整刚好相反

public static void shiftUp(int[] array, int size, int index) {
        int child = index;
        int parent = (child - 1) / 2;
        while (child > 0) {
            // 比较父节点和子节点是否符合堆的要求
            if (array[parent] < array[child]) {
                // 如果不符合大堆的要求, 就交换这两个元素
                int tmp = array[parent];
                array[parent] = array[child];
                array[child] = tmp;
            } else {
                // 只要发现现在的父子节点符合堆要求
                // 就认为现在这个堆已经调整完毕了~
                break;
            }
            // 更新循环变量
            child = parent;
            parent = (child - 1) / 2;
        }
    }

3、创建堆:
方法：从后往前遍历数组，依次进行向下调整。

// createHeap 方法, 看起来时间复杂度就是 O(NlogN)
    // 实际上时间复杂度是 O(N)
    public static void createHeap(int[] array) {
        // 最后一个元素的下标是 length - 1,
        // 目的是从最后一个非叶子节点开始往前循环.
        // 最后一个非叶子节点正是最后一个节点的父节点.
        for (int i = (array.length - 1 - 1) / 2; i >= 0; i--) {
            shiftDown(array, array.length, i);
        }
    }

4、插入元素：
方法：拿当前位置的节点和父节点进行比较，如果当前不符合堆的要求，就交换。

public void offer(int val) {
        if (size >= data.length) {
            // 堆已经满了, 直接插入失败/扩容
            return;
        }
        // 1. 先把新元素放到数组的末尾.
        data[size] = val;
        size++;
        // 2. 加入新的元素之后, 很可能就破坏了原有的堆的结构.
        //    就需要调整堆, 让堆能够重新符合要求.
        //    向上调整的方式~, 从新元素的位置进行向上调整
        shiftUp(data, size, size - 1);
    }

5、获取堆顶元素：
方法：取树根结点的值，即取数组下标为0的位置的值。

// 获取堆顶元素
    public Integer peek() {
        if (size == 0) {
            return null;
        }
        return data[0];
    }

6、删除堆顶元素：
方法：移形换影。

• 先把堆顶元素和最后一个元素互换；
• size–删除最后一个元素；
• 再从0号位置向下调整即可。

 // 删除堆顶元素
    public Integer poll() {
        if (size == 0) {
            return null;
        }
        Integer result = data[0];

        // 先把 0 号元素和最后一个元素互换.
        // 或者直接把最后一个元素给赋值到 0 号元素也成~
        data[0] = data[size - 1];
        // 删除最后一个元素
        size--;
        // 从 0 号位置开始进行向下调整
        shiftDown(data, size, 0);
        return result;
    }