【JAVA数据结构】优先级队列——堆

假装看不见，余光千百遍

大家好，这里是新一，请多关照🙈🙉🙊。在本篇博客中，新一将会为大家介绍数据结构与算法之优先级队列——堆，堆在面试也占了一席之地，所以为了方便大家理解，新一特地给大家附上了 源码和图片 便于大家理解，干货满满哟。（以下结果均在IDEA中编译）希望在方便自己复习的同时也能帮助到大家。😜😜😜🎪🚀🧰

以下是我们的文章

---

---

一.🎪 二叉树的顺序存储

1.1 🚀 堆的表示

我们知道所有数据结构的存储都逃不开我们的顺序存储和链式存储，我们之前所实现的二叉树不难看出来是链式存储，那么接下来我们讲讲二叉树的顺序存储，所谓二叉树的顺序存储——使用数组保存二叉树结构，方式即将二叉树用层序遍历方式放入数组中。一般只适合表示完全二叉树，因为非完全二叉树会有空间的浪费。这种方式的主要用法就是堆的表示

1.2 🚀 下标关系

我们之前讲完全二叉树的时候，讲过有以下关系：

链接戳这里：👇👇👇

高效学习二叉树之基础篇

已知双亲(parent)的下标，则：左孩子(left)下标 = 2 * parent + 1;右孩子(right)下标 = 2 * parent + 2

已知孩子（不区分左右）(child)下标，则：双亲(parent)下标 = (child - 1) / 2

二.🎪 堆

2.1 🚀 堆的要素

1. 堆逻辑上是一棵完全二叉树
2. 堆物理上是保存在数组中
3. 满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆
4. 反之，则是小堆，或者小根堆，或者最小堆
5. 堆的基本作用是，快速找集合中的最值

2.2 🚀 建堆——向下调整法

下面我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。根节点左右子树不是堆，我们怎么调整呢？当我们从倒数的第一个非叶子节点的子树开始调整，一直调整到根节点的树，就可以调整成堆

但是我们调整越往上的节点时，它们之间值的交换，又会影响下面的节点，所以说我们的向下调整法之间应该有个循环，一直往下调整才行

public class TestHeap {
    public int[] elem;
    int usedSize;

    public TestHeap() {
        this.elem = new int[10];
    }

    /**
     * 向下调整
     * @param parent 每棵树的根节点
     * @param len 每棵树调整的结束位置
     */
    public void shiftDown(int parent, int len) {
        int child = 2 * parent + 1;

        //数学公式推导 - 错位相减 - 时间复杂度O(n)
        //1.循环依次修改位置
        while (child < len) {//向下调整一直到根
            if (child + 1 < len && elem[child] < elem[child + 1]){//判断是否已经是叶子结点或者当前堆已经为大根堆
                child++;
            }
            if (elem[parent] < elem[child]){//交换
                int ret = elem[parent];
                elem[parent] = elem[child];
                elem[child] = ret;
            }else{
                break;
            }
            parent = child;//向下调整具体操作
            child = child * 2 + 1;
        }
    }
    public void createHeap(int[] array){
        for (int i = 0; i < array.length; i++) {
            elem[i] = array[i];
            usedSize++;
        }
        for (int parent = (usedSize - 2) / 2; parent >= 0; parent--) {
            shiftDown(parent,usedSize);
        }
    }
}

2.3 🚀 建堆——时间复杂度分析

当最坏情况时，我们每一次向下调整是不是都得调整到根节点，时间复杂度为整棵树的高度——O(log(n))，在遍历整棵树时间复杂度为O(n)，那么建堆的时间复杂度是否为O(n * log(n))呢？——当然不是，我们来看看以下对建堆时间度的分析：

建堆时间复杂度O(n)怎么来的？

三.🎪 堆的应用——优先级队列

3.1 🚀 优先级队列——堆

在很多应用中，我们通常需要按照优先级情况对待处理对象进行处理，比如首先处理优先级最高的对象，然后处理次高的对象。最简单的一个例子就是，在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话。
在这种情况下，我们的数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue)

public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();

        //每次入队的时候，都得保证当前是大堆或者小堆
        priorityQueue.offer(12);
        priorityQueue.offer(3);
        priorityQueue.offer(15);

        //保证每次弹出后，也得保证是小堆或者大堆
        System.out.println(priorityQueue.peek());
        System.out.println(priorityQueue.poll());
        System.out.println(priorityQueue.poll());

    }

3.2 🚀 入队优先级队列——模拟实现

相信理解了向下调整理解向上调整也不难。

过程（以大堆为例）：

1. 首先按尾插方式放入数组
2. 比较其和其双亲的值的大小，如果双亲的值大，则满足堆的性质，插入结束
3. 否则，交换其和双亲位置的值，重新进行 2、3 步骤
4. 直到根结点

private void shiftUp(int child){
        int parent = (child - 1) / 2;
        while (parent >= 0){
            if (elem[parent] < elem[child]){
                int ret = elem[parent];
                elem[parent] = elem[child];
                elem[child] = ret;
            }else{
                break;
            }
            child = parent;
            parent = (parent - 1) / 2;
        }
    }

    public void offer(int val){
        if (isFull()){
            elem = Arrays.copyOf(elem, 2 * elem.length);
        }
        elem[usedSize++] = val;
        shiftUp(usedSize - 1);
    }

    public boolean isFull(){
        return usedSize == elem.length;
    }

3.3 🚀 出队优先级队列——模拟实现

为了防止破坏堆的结构，删除时并不是直接将堆顶元素删除，而是用数组的最后一个元素替换堆顶元素，然后通过向下调整方式重新调整成堆

public int poll(){
        if (isEmpty()){
            throw new RuntimeException("优先级队列为空！");
        }
        int ret = elem[0];
        elem[0] = elem[usedSize - 1];
        elem[usedSize - 1] = ret;
        usedSize--;
        shiftDown(0,usedSize);

        return ret;
    }

    public boolean isEmpty() {
        return usedSize == 0;
    }

想对大家说的话

💕家人们，学到这里我们的数据结构与算法中的堆已经彻底弄懂啦，后续新一将会对面试高频考点关于堆的部分给大家整理出来，如果觉得新一讲得还清楚的话，可以点个赞收藏一下支持一下哦🥳🥳🥳，后续新一会持续更新JAVA的有关内容，学习永无止境，技术宅，拯救世界！