详解堆（heap）

最新推荐文章于 2024-05-09 08:03:35 发布

Guo_j_

最新推荐文章于 2024-05-09 08:03:35 发布

阅读量332

点赞数

分类专栏： Java基础数据结构与算法文章标签：数据结构算法

本文链接：https://blog.csdn.net/TylerGuoj/article/details/120369353

版权

Java基础同时被 2 个专栏收录

21 篇文章 0 订阅

订阅专栏

数据结构与算法

6 篇文章 0 订阅

订阅专栏

定义

满二叉树
最后一层全部都是叶子节点，其他各层的所有节点都有两个子节点的二叉树。其特点是第k层有 2^k-1个节点，整棵二叉树有2^k-1个节点。
完全二叉树
若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边。

观察满二叉树可以发现，从根节点开始，对满二叉树排序（1-based）,可以发现对于序号为 i 的节点，其左孩子的序号为 2 * i ，其右孩子的序号为 2 * i + 1。从定义可知，完全二叉树存在节点的位置和满二叉树是重合的，因此满二叉树的父子序号关系同样适用于完全二叉树，即父子节点的序号间存在数学关系。又因为完全二叉树最后一层不必全部填满，且相比于满二叉树缺失节点都在最后一层的右边，这使得存储时有了一定的灵活性。以上可得，完全二叉树具备两个特点

易索引 注意此处的索引指具备父子关系节点（存在数学关系）上的编号关系
存储灵活 相比于满二叉树，只在最后一层的最右边依次缺少若干节点。

从使用角度来说，每一种数据结构的特点决定其使用的场景。对于一般完全二叉树，其特点并没有太多有用之处。若在完全二叉树的结构基础之上，添加适当限制，则有可能适用某些特定场景。依此原则，限定完全二叉树中父子节点的关系，则可出现堆（heap）的如下定义

堆在逻辑上是一颗完全二叉树，不一定是满二叉树
节点的值总是不大于其父节点的值的堆称为最大堆，此时根节点最大（大顶堆）。
节点的值总是不小于其父节点的值的堆称为最小堆，此时根节点最小（小顶堆）。

特别注意的是，定义只限制了父子节点间的关系，兄弟节点间不具备大小关系，即第三层部分节点可以大于第二层部分节点。

底层存储

任何一种数据结构都可以采用顺序存储结构或链式存储结构，需根据数据结构自身的特点（元素之间的关系）从两者中选取。一般情况下，树型结构要维护父子关系，多采用链式存储，即递归定义节点，节点中存储元素值和父子关系，但完全二叉树是个特例。上文已描述，完全二叉树进行层次遍历输出的父子元素之间存在数学关系，即将树型结构转化为线性结构后，元素之间的关系隐含在线性结构的位置序号中。而对于线性结构，数组（顺序存储）是一种常用的底层实现。

由于在java中数组是0-based，因此底层采用数组存储二叉堆时，其父子节点的关系如下

若节点的数组下标为i，则其父节点的数组下标为（i - 1） / 2，同时结果需取整。例如数组下标为3的元素的父节点的数组下标为1 【（3 - 1）/ 2 】。数组下标为4的元素的父节点的数组下标为1 【（ 4 - 1 ) / 2 】。
若节点的数组下标为i,若该节点有子节点，则其左孩子的数组下标为 2*i + 1,右孩子的数组下标为`2*i + 2.例如数组下标为3的元素的左子树的数组下标为7【2 * 3 + 1】，其右子树的数组下标为8【2 * 3 + 2】。

右子树的数组下标 = 左子树的数组下标 + 1

核心操作

同其他数据结构类似，堆的操作不外乎增删改查。但由于堆需要维护父子之间的大小关系，因此当数据元素发生变化时（增删改）需要执行调整操作，使增删改之后整个堆仍满足定义。堆的核心操作包括上浮和下沉两种。

上浮（siftUp）

前文已介绍，对采用一维的数组存储二维的堆。当堆执行添加元素时，先将新元素添加在数组尾部（此时在堆中该节点位于最下层的最右边），然后根据父子节点在数组中的索引关系，逐个对比父子大小，当儿子 > 父子时，调换父子位置，直至找到合适位置。当新元素比较大时，会发生多次交换过程，整个过程新元素看起来像是在上浮。

下沉（siftDown）

从堆的定义可知，堆顶是整个堆的极值（最大或最小）。当极值被取走之后，需要从新找到极值。由于堆是采用数组存储元素，为了破坏最小范围的有序性实现整个堆的有序性，可将数组的最后一个元素E移动至堆首，然后将该元素与其左右子树节点（如果有的话）比较大小，同左右子树中较大者交换位置，递归该过程，直至整个堆满足定义。当元素E比较小时，会发生多次交换过程，整个过程元素看起来像是在下沉。

源码

package com.company.maxheap;

/**
 * @description: 最大堆
 * @Date: 2021/9/16 9:57
 */
public class MaxHeap<E extends Comparable<E>> {
    //动态数组存储作为实际存储元素的底层数据结构
    private Array<E> data;
    public MaxHeap(int capacity){
        data = new Array<>(capacity);
    }
    public MaxHeap(){
        data = new Array<>();
    }

    /**
     * 使用数组构造最大堆
     * @param arr
     */
    public MaxHeap(E[] arr){
        data = new Array<>(arr);
        for(int i = parent(arr.length - 1); i >= 0; i--){
            siftDown(i);
        }
    }

    public int getSize(){
        return data.getSize();
    }
    public boolean isEmpty(){
        return data.isEmpty();
    }

    /**
     * 0-based
     * 获取数组索引为k的节点的父节点数组索引
     * 注意判断根节点没有父节点
     * @param k
     * @return
     */
    public int parent(int k){
        if(k == 0){
            throw new IllegalArgumentException("0没有根节点");
        }
        return (k - 1) / 2;
    }

    /**
     * 获取数组索引为k的节点的左孩子的”逻辑“数组索引
     * 逻辑的意思是指 这个结果是计算出来的理论值，可能会大于组的size，
     * 即在数组中当前不存在该索引
     * 0-based
     * @return
     */
    public  int  leftChild(int k){
        return 2 * k + 1;
    }

    /**
     * 0-based
     * 获取数组索引为k的节点的右孩子的”逻辑“数组索引
     * 逻辑的意思是指 这个结果是计算出来的理论值，可能会大于数组的size，
     * 即在数组中当前不存在该索引
     * @param k
     * @return
     */
    public int rightChild(int k){
        return 2 * k + 2;
    }

    /**
     * 外部接口
     * 向堆中添加添加元素
     * 基于最大堆 “父 >= 子”的特点，在插入之后需要要调整的位置
     * 使最大堆仍旧保持整体有效
     * @param e
     */
    public void add(E e){
        //step1  将元素插入数组尾部
        data.addLast(e);
        //step2  调整位置
        //维持最大堆的特点的大小关系体现在父子在数组元素的下标索引的数学关系上
        //因此只需传入数组索引，即可根据数学关系开始调整
        siftUp(data.getSize() - 1);
    }
    /**
     *根据父子节点的数组元素索引的数学关系
     * 以给定的数组索引下标为起点，向上递归与父节点对比，
     * 若大于父节点值，则父子调换位置，直至小于等于父节点值
     * 注意比较路径只在 子 - 父 - 父的父 - 父的父的父 -...
     * @param k
     */
    private void siftUp(int k){
        //虽然（k - 1)/2和parent(k)都是获取父节点，但优先使用parent(k)方法。
        //while(k > 0 && data.get(k).compareTo(data.get((k - 1)/2)) > 0){
        while(k > 0 && data.get(k).compareTo(data.get(parent(k))) > 0){
            data.swap(k, (k - 1) / 2);
            k = parent(k);
        }
    }

    public E getMax(){
        if(getSize() == 0){
            throw new IllegalArgumentException("堆为空");
        }
        return data.get(0);
    }
    /**
     * 取出最大元素
     * 注意使移除，需要重新排序
     * 思路：暂存数组索引0的元素（目标值），将数组尾部的元素与数组首位互换
     * 删除此时数组的最后一位元素
     * 调整堆，即寻找数组索引0的元素的最终位置
     * 从堆的角度看，是从堆顶向下移动，下沉操作。
     * @return
     */
    public E extractMax(){
        if(isEmpty()){
         throw new IllegalArgumentException("堆为空");
        }
        E max = data.get(0);
        //step1 互换数组首位和最后一位的元素,保证仍是一个完全二叉树
        data.swap(0,data.getSize() - 1);
        //step2 删除数组最后一位的元素，即目标值
        data.remove(data.getSize() - 1);
        //step3 调整堆 保证是父>子
        siftDown(0);
        return max;
    }

    /**
     * 堆顶元素下称
     * 实质是在符合堆的特点的前提下，寻找数组索引为k的元素的目标位置
     * @param k
     */
    private void siftDown(int k){
        //判断 逻辑左子树 是否在数组的有效范围内。若超出范围，说明堆顶元素已彻底下沉。
        //使用左子树的原因：假设使用右子树，则可能出现右子树已出界，
        // 但左子树不出界的情况，且最终目标位置是左子树，导致堆顶元素未下沉到目标位置
        while(leftChild(k) < data.getSize()){
            //以下代码： 在左右子树存在的情况下，找出两者中元素较大的子树在数组中的索引位置
            //setp1 bigger中存储左右子树值较大的数组索引
            // 初始时暂存左子树的位置
            int bigger = leftChild(k);
            //step2-1 判断逻辑右子树是否越界
            if(rightChild(k) < data.getSize()
                    //step2-2 比较左右子树值大小 若右子树大，则更新bigger
            && data.get(leftChild(k)).compareTo(data.get(rightChild(k))) < 0){
                bigger = rightChild(k);
            }
            //step3-1 比较父节点和较大子节点的大小。
            //若父 >= 子 ，说明堆顶已经下沉到位，循环终止。
            if(data.get(k).compareTo(data.get(bigger)) >= 0){
                break;
            }
            //step3-2 父节点 < 子节点 说明堆顶未下沉到位，
            data.swap(k,bigger);
            //更新位置继续循环下沉
            k = bigger;
        }
    }

    /**
     * 取出最大元素，并插入一个新元素
     * @param e
     * @return
     */
    public E replace(E e){
        E ret = extractMax();
        data.set(0,e);
        siftDown(0);
        return ret;
    }
}

优先队列

优先队列是堆的一种典型应用，指是带有优先级的队列。虽然中心词是队列，但优先队列的操作逻辑不同于一般的队列（先进先出）。与普通队列不同的时，出队根据当前优先级最高的出队，而元素优先级是动态变化。即优先队列每次出队的依据是当前所有元素的极值，跟元素进入优先队列的次序无关，而一般队列每次出队的元素是当前队列中入队最早的元素，同入队次序有关。

使用优先队列名称目的可能是使用队列的功能接口，其在底层实现上，有三种方式

普通线性结构（链表或数组）入队正常操作O(1)，出队需要找到当前最高优先级的元素，要遍历所有元素O(n)
顺序线性结构在普通线性结构的基础上，使用额外空间维护元素的优先级顺序（正序或倒叙）。此时出队只需取出队首或队尾O(1)，入队操作需要维护当前顺序，要遍历所有元素的优先级O(n)
堆入队和出队都是logn

基于堆实现的优先队列源码如下

package com.company.maxheap;

import com.company.queue.Queue;

/**
 * @description: 优先队列
 * 泛型E可以比较 其比较的元素可看作优先级，进而实现外部用户的优先队列
 * @Date: 2021/9/17 10:03
 */
public class PriorityQueue<E extends Comparable<E>> implements Queue<E> {
    private MaxHeap<E> maxHeap;

    public PriorityQueue() {
        this.maxHeap = new MaxHeap<>();
    }

    @Override
    public void enqueue(E e) {
        maxHeap.add(e);
    }

    @Override
    public E dequeue() {
        return maxHeap.extractMax();
    }

    @Override
    public E getFront() {
        return maxHeap.getMax();
    }

    @Override
    public int getSize() {
        return maxHeap.getSize();
    }

    @Override
    public boolean isEmpty() {
        return maxHeap.isEmpty();
    }
}

Guo_j_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
详解堆（heap）

定义满二叉树最后一层全部都是叶子节点，其他各层的所有节点都有两个子节点的二叉树。其特点是第k层有 2k-1个节点，整棵二叉树有2k-1个节点。完全二叉树若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边。观察满二叉树可以发现，从根节点开始，对满二叉树排序（1-based）,可以发现对于序号为 i 的节点，其左孩子的序号为 2 * i ，其右孩子的序号为 2 * i + 1。从定义可知，完全二叉树存在节点的位置和
复制链接

扫一扫