【Java】数据结构---优先级队列（堆） 详解

1 堆的存储方式

1.1 堆的表示：

使用数组保存二叉树结构，方式即将二叉树用层序遍历方式放入数组中。
一般只适合表示完全二叉树，因为非完全二叉树会有空间的浪费。

1.2 下标关系

已知双亲(parent)的下标，则：

左孩子(left)下标 = 2 * parent + 1;
右孩子(right)下标 = 2 * parent + 2;

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

2 堆（heap）

2.1 概念

1. 堆逻辑上是一棵完全二叉树

2. 堆物理上是保存在数组中

3. 满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆

4. 反之，则是小堆，或者小根堆，或者最小堆

5. 堆的基本作用是，快速找集合中的最值
   

2.2 向下调整操作 代码实现

以调整为大根堆为例子

注意：

1. 调整是从最后一棵子树出发的
2. 每棵子树的调整都是向下调整的

/**
     * 向下调整函数的实现
     * @param parent 每棵树的根节点
     * @param len 每棵树的调整的结束位置  10
     */
    public void shiftDown(int parent,int len) {
        int child = 2*parent+1;
        //1、最起码 是有左孩子的，至少有1个孩子
        while (child < len) { //循环结束条件；比如10个数据最大下标就是9
            if(child+1 < len && elem[child] < elem[child+1]) {
                child++;//保证当前左右孩子最大值的下标
            }
            if (elem[child]>elem[parent]){ //交换过程 
                int tmp=elem[child];
                elem[child]=elem[parent];
                elem[parent]=tmp;
                parent=child;//向下调整 
                child=2*parent+1; 
            }else {
                break;
            }
        }
    }

时间复杂度分析：
最坏的情况，从根一路比较到叶子，比较的次数为完全二叉树的高度
即时间复杂度为 O(log(n))

2.3 操作 — 建堆

以建一个大根堆为列：

public class TestHeap {
    public int[] elem; //依据数组来建堆
    public int usedSize; //当前数组中元素个数（相应下标为元素个数-1）

    public TestHeap() {
        this.elem = new int[10]; 
    }
    
    public void createHeap(int[] array) {
        for (int i = 0; i < array.length; i++) {
            elem[i] = array[i];
            usedSize++;
        }
        //从最后一棵子树建起
        for (int parent = (usedSize-1-1)/2; parent >= 0 ; parent--) {
            //每次建堆都需要重新向下调整
            shiftDown(parent,usedSize);
        }
    }

时间复杂度分析：
粗略估算，可以认为是在循环中执行向下调整，为 O(n * log(n)) （节点个数*高度）
但是，实际上是 O(n) （错位相消法得出）
那么，堆排序中建堆过程时间复杂度O(n)怎么来的？
相关推导过程可以参考这个链接，点击跳转！

3. 堆的应用-优先级队列

3.1 概念

在很多应用中，我们通常需要按照优先级情况对待处理对象进行处理，比如首先处理优先级最高的对象，然后处理次高的对象。

在这种情况下，我们的数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue)

3.2 内部原理

优先级队列的实现方式有很多，但最常见的是使用堆来构建。

3.3 操作 — 入队列

过程（以大堆为例）：

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

3.3.1 向上调整函数实现

因为入队是从尾入的，所以每入一次都需要向上调整，具体代码实现如下;

  private void shifUp(int child) {
        int parent = (child - 1) / 2;

        while (child>0) {
            if (elem[child] > elem[parent]) {
                int tmp = elem[child];
                elem[child]=elem[parent];
                elem[parent]=tmp;
                child = parent; //向上调整
                parent = (child - 1) / 2;
            } else {
                break;
            }
        }
    }

3.3.2 入队操作代码实现

    public void offer(int val){
        if (isFull()){
            //扩容
            elem= Arrays.copyOf(elem,2*elem.length);
            elem[usedSize++]=val;
            //注意这里传入的是usedsise-1
            shifUp(usedSize-1);
        }
    }
    public boolean isFull(){
        return usedSize==elem.length;
    }

3.4 操作-出队列（优先级最高）

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

 /**
     *  出队列：
     *     1.交换0下标元素和最后一个下标元素
     *     2.向下调整0下标这棵树就可以了；
     * @return 出队列的值
     */
    public int poll(){
        if (isEmpty()){
            throw new RuntimeException("优先级队列为空！");
        }
        int tmp = elem[0];
        elem[0]=elem[usedSize-1];
        elem[usedSize-1]=tmp;

        shiftDown(0,usedSize);
        return tmp; //出的就是原来的堆顶元素

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

3.5 返回队首元素（优先级最高）

返回堆顶元素即可

 public int peek(){
        if (isEmpty()){
            throw new RuntimeException("优先级队列为空！");
        }
        return elem[0];
    }


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

4. 堆的其他应用-堆排序

升序排序（从小到大排序，借助的应该是一个大根堆！）
降序排序（从大到小排序，借助的应该是一个小根堆！）

下面进行的是借助大根堆的升序排序：

public void heapSort(){
        int end=this.usedSize-1;
        while (end>0){
            int tmp=elem[0];
            elem[0]=elem[end];
            elem[end]=tmp;
            shiftDown(0,end); //向下调整为大顶堆 
            end--;
        }
    }

排序前：

排序后：

完结

有关 数据结构—优先级队列（堆） 的讲解以及实现到此就结束了~
如果觉得博主的文章对你有所帮助，欢迎大家多多点赞收藏 ~