堆的基础知识

薛定谔的__猫

已于 2023-08-19 09:52:54 修改

阅读量93

点赞数 1

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

于 2023-04-05 17:30:45 首次发布

本文链接：https://blog.csdn.net/m0_64188165/article/details/129972805

版权

数据结构同时被 2 个专栏收录

11 篇文章 1 订阅

订阅专栏

Java基础知识

8 篇文章 0 订阅

订阅专栏

堆

堆是什么

堆是为了解决动态的查找最值而产生的。

堆的性质

逻辑上是一棵完全二叉树,也就是说除了最后一层其他层都是满的，它的存储是按照二叉树的层序遍历来存储的。基于这个特性，往往使用数组来实现堆，使得操作更加高效。
树中的任意一个结点，只要有孩子，大堆： parent 的值 >= 两个孩子的值，小堆： parent 的值 <= 两个孩子的值。堆顶的元素一定是最大（大堆）或者最小的（小堆）。但是不保证整个堆是按照顺序排列的。
堆支持高效的插入、删除和获取最值操作。在插入元素时，可以保持堆的性质，通过一次或多次元素的交换，实现对堆的调整。
堆常常被用于实现优先级队列，根据堆的特性可以快速获得最大或最小的优先级元素。
除了最大堆和最小堆之外，还可以存在其他类型的堆，例如基于中位数的堆。具体取决于应用场景和需求。

堆的分类

最常用的堆有大堆和小堆：0下标元素（堆顶元素）是最大值的是大堆，0下标元素是最小值的是小堆。

堆元素和数组下标的关系

因为堆是用顺序表实现的，所以堆中的元素就可以用下标来表示了，那么堆中的元素和数组下标的关系是什么呢？（left:左孩子 right:右孩子 parent:父元素）

left=parent*2 + 1

right=parent*2 + 2

那么也可以逆着求出： parent = (child - 1) / 2，不管左右孩子，减一除2取整就好了。

向下调整和向上调整

向下调整和向上调整的时候，有一个前提就是，除了要调整的位置，其余位置都要满组堆的性质。例如：如果是大堆的话，除了要调整的位置，其余位置就必须要满足parent元素大于等于左后孩子元素，这样才可以进行调整。

大堆向下调整，小堆向上调整。调整的时候首先判断要调整的位置是否满足堆的性质。

堆的性质

一个孩子都没有----满足堆的性质
只有一个孩子----一定是左孩子，因为堆是完全二叉树。大堆的话就要满足：parent 的值> =左孩子的值；小堆：parent的值<=左右孩子
有两个孩子,大堆：parent的值>=左右孩子，也就是大于左右孩子中最大的那个；小堆：parent的值<=左右孩子，也就是小于左右孩子中最小的那个。

若是满足对的性质就不需要调整。若是不满足上边的性质，就调整parent和孩子的位置，调整到满足性质。在小范围调整完毕，扩大范围，查看其他位置是否被破坏了，若是破坏了，就进行刚才一样的操作进行调整。直到全部满足，到达叶子节点。

向下调整

在进行调整之前我们说了有前提，就是其他位置都要满足堆的性质，在其他位置都满足的情况下，我们从堆顶元素开始进行调整，所以是向下进行调整。

最坏就是每层都进行调整，调整的范围直接蔓延到整棵树，进行书的高度次，也就是O（logN）

//调整的数组  调整数组的大小  
//要调整的元素
public static void shiftDown(long[] array,int size,int index){
        //如果这个位置已经是叶子，那么就不需要在进行调整了
        while(true){
            int leftIdx=index*2+1;//左孩子的下标
            if(leftIdx>=size){//左孩子不存在,那么说明已经是叶子了
                return;
            }
            //找出孩子中最大的一个
            int maxIdx=leftIdx;
            if(leftIdx+1<size && array[leftIdx+1]>array[leftIdx]){
                maxIdx=leftIdx+1;
            }
            //满足组堆的性质，则直接退出
            if(array[index]>array[maxIdx]){
                return;           
            }
            //不满足堆的性质，要进行交换操作
            long t=array[index];
            array[index]=array[maxIdx];
            array[maxIdx]=t;

            //交换完毕后，记得还要对交换过的位置继续进行向下调整
            //要改变循环变量的值
            index=maxIdx;
        }

    }

建堆操作（大堆）

建堆就是：把一个无序顺序表变为堆。

过程就是：一个数组进行层序排列，排序结束之后进行调整操作，调整操作就是从最后一个元素的双亲元素开始向前进行向下遍历。

    /**
     * 向下调整
     * @param array 要调整的数组
     * @param size 数组的长度
     * @param index 要调整的元素的下标
     */
    public static void shiftDown(long[] array,int size,int index){
        //叶子元素就不需要在进行调整了
        while(true){
            //要调整的数的左孩子
            int leftIndex=index*2+1;
            //左孩子不存在,说明就是叶子
            if(leftIndex>=size){
                return;
            }
            //如果左孩子存在，开始进行判断是否满足堆的特性
            //判断右孩子是否存在
            int max=leftIndex;
            if(leftIndex+1<size) {
                //找出左右孩子的最大值的下标
                max = array[leftIndex] > array[leftIndex + 1] ? leftIndex : leftIndex + 1;
            }
            //开始进行判断是否满足堆的特性
            if(array[index]>array[max]){
                return;
            }
            //不满足则进行交换
            long temp=array[index];
            array[index]=array[max];
            array[max]=temp;

            //交换完毕后，继续进行向下调整
            index=max;
        }

    }
    //建堆，就是从最后一个元素的双亲结点向前进行向下调整
    //size-1最后一个元素
    public static void createHeap(long[] array,int size){
        for(int i=(size-2)/2;i>=0;i--){
            shiftDown(array,size,i);
        }
    }

    public static void main(String[] args) {
        long[] array={3,9,7,6,8,8,2,4,1,7};
        int size=10;
        createHeap(array,size);
        System.out.println(Arrays.toString(array));
    }

显示以上结果就是正确的。以上的建堆的时间复杂度，最大是O(N*log(n)),最少是O(N).

注意：因为底层是顺序表实现的，可以用下标，所以向下调整的时候也是用的下标来调整。

删除元素

堆中不能任意删除元素，只能删除堆顶的元素。任意删除会破坏堆的特性，使得堆无法快速复原。

过程是：堆顶元素和最后一个元素进行交换位置，然后删除最后位置的元素，也就是通过替换的方式删除原本的堆顶元素。这个时候，堆顶元素得到了删除，最后一个位置的元素不满足堆的性质，但是只用进行一次O（log（N））的向下调整就会得到一个新的堆。

 //删除元素
    public void deleteMax(){
        //堆中只剩一个元素，无需操作
        if(size<=1){
            return;
        }
        //将最后一个元素移到根节点

        array[0]=array[size-1];
        size=size-1;
        //进行向下调整
        shiftDown(array,size,0);

    }

向上调整

添加元素

public static void shiftUp(long[] array,int index){
        while(true){
            int parentIdx=(index-1)/2;
            if(index==0){
                return;//0号下标元素，直接退出
            }
            if(array[parentIdx]>=array[index]){
                return;
            }
            //需要调整
            long t=array[parentIdx];
            array[parentIdx]=array[index];
            array[index]=array[parentIdx];

            //调整完毕记得还要对调整过的位置继续进行向上调整
            index=parentIdx;
        }
    }

插入操作的时间复杂度：O(log(n))。

总结

以上就是堆的相关操作，可以看到他的插入和删除都是O（log（n）)的时间复杂度。效率很高，创建堆的过程最大时间复杂度O（N*log(n)）,最小也是O（log（n）)。

堆最大的特点就是能够动态的找到最值，也是这样体现的。

薛定谔的__猫

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
堆的基础知识

以上就是堆的相关操作，可以看到他的插入和删除都是O（log（n）)的时间复杂度。效率很高，创建堆的过程最大时间复杂度O（N*log(n)）,最小也是O（log（n）)。堆最大的特点就是能够动态的找到最值，也是这样体现的。
复制链接

扫一扫