数据结构中的堆--堆的定义、调整堆、建堆、自定义堆

最新推荐文章于 2024-09-04 08:13:48 发布
最新推荐文章于 2024-09-04 08:13:48 发布
阅读量1w 收藏 36
点赞数 11
分类专栏： 数据结构 七大排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smell201611010513/article/details/89951421
版权

一、堆的定义

1.结构特点

堆（数据结构）和Java语言中提到的堆没有一点关系。
          逻辑上：完全二叉树
          物理上：数组

堆是一种顺序存储结构（采用数组方式存储），仅仅是利用完全二叉树的顺序结构的特点进行分析。

2.结点下标计算公式（根节点从0开始）

已知二叉树根结点的下标是root,那么它左孩子的下标left=2*root+1，右孩子的下标right=2*root+2。

已知孩子结点的下标（不区分左右）为child，那么双亲的下标为（child-1)/2。

如果从1开始，则已知root，则左孩子节点left=2*root+1,right=2*root+2。已知child，则其根结点root=child/2.

3.堆的定义和性质

将满足根的值小于等于所有子树结点的值，称为小堆；根的值大于等于所有子树结点的值称为大堆。

堆的作用：找最值。

4.练习

（1）{9，10，13，17，21，14，13，22}   小堆

（2）{10，8，3，8，8，2，1，7，6} 大堆

（3）{10，7，6，5，5，7，3，4，2}  既不是大堆也不是小堆

二、调整堆

1.向下调整（堆化）

向下调整的前提：对于一棵完全二叉树，除了一个位置外，所有其它位置都已经满足堆的性质了。

给定一个表示完全二叉树的数组和要调整的下标，如果该结点下标是叶子结点，那么不需要调整。如果不是叶子结点，这里假设是大堆，则调整步骤为：

1）计算出它的左右孩子下标，并判断是否越界。left=2*root+1,right=2*root+2.  若left>array.length，说明越界；否则没有越界。

2）找出它的左右孩子的较大值。右孩子结点可能没有，较大值是右孩子的条件是：right<array.length&&array[right]>array[left]。不满足这个条件可以认为较大值结点是左孩子。

3）将较大值和根结点值进行比较，如果根结点值较大，则不需要调整，直接返回；否则，继续向下调整。将要调整的结点修改为较大值的下标。

package heap;

public class TestHeap {
    //递归写法
    private static void adjustDown(int[] array,int root){
        //1.计算左右下标
        int left=2*root+1;
        int right=2*root+2;
        //判断是否越界
        if(left>=array.length){
            return;
        }
        //2.找左右孩子的最大值下标
        int max=left;
        if(right<array.length&&array[right]>array[left]){
            max=right;
        }
        //3.和根结点的值比较
        if(array[root]>=array[max]){
            return;
        }
        //交换
        int temp=array[root];
        array[root]=array[max];
        array[max]=temp;
        //继续向下调整
        adjustDown(array,max);
    }
    public static void main(String[] args) {
        int[] array=new int[]{10,7,6,5,5,7,3,4,2};//6不符合，调整的下标为2
        adjustDown(array,2);
        for(int item:array){
            System.out.print(item+" ");
        }
    }
}

非递归写法，终止条件仍然为越界判断。因此非递归的步骤为：

1）先假定没有越界，计算出最大坐标为max=2*root+1.

2）判断是否满足终止条件（max>=array.length),如果满足，则终止；不满足，则计算右孩子的下标。

3）找出较大的孩子下标

4）将较大的孩子值与根的值进行比较，如果根的值也大于孩子的值，则循环终止。否则进行下一步。

5）交换两个下标的值。并修改新的root和max，root=max,max=2*root+1。

package heap;

public class TestHeap {
    //非递归写法
    private static void adjustDownNoR(int[] array,int root){
        //
        int max=2*root+1;
        while(max<array.length){
            if(max+1<array.length&&array[max+1]>array[max]){
                max=max+1;
            }
            //比较根节点的值与max的值
            if(array[root]>array[max]){
                break;//循环终止
            }
            //交换
            int temp=array[max];
            array[max]=array[root];
            array[root]=temp;

            //重新赋值
            root=max;
            max=2*root+1;
        }

    }
    public static void main(String[] args) {
        int[] array=new int[]{10,7,6,5,5,7,3,4,2};//6不符合，调整的下标为2
        adjustDownNoR(array,2);
        for(int item:array){
            System.out.print(item+" ");
        }
    }
}

如果是小堆的向下调整，代码为：

package heap;

public class SmallHeap {
    private static void adjustDown(int[] array,int index){
       //1.计算左右下标
        int left=2*index+1;
        int right=2*index+2;
        //判断是否越界
        if(left>=array.length){
            return;
        }
        //2.找左右孩子中的较小值
        int min=left;
        if(right<array.length&&array[right]<array[left]){
            min=right;
        }
        //3.比较根结点的值和较小值
        if(array[index]<=array[min]){
            return;
        }
        //交换
        int temp=array[min];
        array[min]=array[index];
        array[index]=temp;

        adjustDown(array,min);
    }

    private static void adjustDownNoR(int[] array,int index){
        int min=2*index+1;
        while(min<array.length){//终止条件
            //找较小值
            if(min+1<array.length&&array[min+1]<array[min]){
                min=min+1;
            }
            //比较
            if(array[index]<=array[min]){
                return;
            }
            //交换
            int temp=array[min];
            array[min]=array[index];
            array[index]=temp;

            //重新赋值
            index=min;
            min=2*index+1;
        }
    }

    public static void main(String[] args) {
        int[] array=new int[]{13,8,10,13,12,11,12,14};
        adjustDown(array,0);
        for(int item:array){
            System.out.print(item+" ");
        }
        System.out.println();
        adjustDownNoR(array,0);
        for(int item:array){
            System.out.print(item+" ");
        }
    }
}

2.向上调整

和向下调整不同的是，每次比较的对象变为双亲结点值。终止条件为比不过或者到达最顶端（没得比了）。假设为大堆，步骤为：

1）计算parent。parent=(index-1)/2

2）判断parent是否大于0，如果大于，进入下一步；小于，说明越界，当前结点已经是根结点，不能继续向上调整。

3）比较双亲结点的值和要调整的结点的值。如果双亲结点值较大，则不用比了，跳出循环；否则交换两个对应下标的值。

4）修改index和parent，继续下一次循环。index=parent,parent=(index-1)/2。

    //大堆的向上调整  根结点值>=孩子结点
    private static void adjustUp(int[] array,int index){
        //计算双亲结点
        int parent=(index-1)/2;
        while(parent>0){
            //比较值
            if(array[parent]>=array[index]){
                break;
            }
            //交换值
            int temp=array[parent];
            array[parent]=array[index];
            array[index]=temp;
            //修改值，进行下一次循环
            index=parent;
            parent=(index-1)/2;
        }
    }
    public static void main(String[] args) {
        int[] array=new int[]{10,7,6,5,5,7,3,4,2};//6不符合，调整的下标为2
        adjustUp(array,5);
        for(int item:array){
            System.out.print(item+" ");
        }
    }

三、建堆

叶子结点本来就是一个堆。对每一个根结点，只要满足它的左右子树都是堆即可。因此从最后一个非叶子结点开始，依次进行向下调整堆，直到根结点为止，此时整个二叉树就是一个堆。

怎么找最后一个非叶子结点？最后一个非叶子结点就是最后一个结点的双亲，下标即(array.length-1-1)/2=(array.length-2)/2.

package heap;

public class TestHeap {
    //大堆的递归写法
    private static void adjustDown(int[] array,int root){
        //1.计算左右下标
        int left=2*root+1;
        int right=2*root+2;
        //判断是否越界
        if(left>=array.length){
            return;
        }
        //2.找左右孩子的最大值下标
        int max=left;
        if(right<array.length&&array[right]>array[left]){
            max=right;
        }
        //3.和根结点的值比较
        if(array[root]>=array[max]){
            return;
        }
        //交换
        int temp=array[root];
        array[root]=array[max];
        array[max]=temp;
        //继续向下调整
        adjustDown(array,max);
    }

    //建大堆
    private static void createHeap(int[] array){
        for(int i=(array.length-2)/2;i>=0;i--){
            adjustDown(array,i);
        }
    }
    public static void main(String[] args) {
        int[] array=new int[]{4,3,2,1,6,9,15,40};//6不符合，调整的下标为2{10,7,6,5,5,7,3,4,2}
       createHeap(array);
        for(int item:array){
            System.out.print(item+" ");
        }
    }
}

四、自定义一个堆类

package com.xunpu.datastruct;

import java.util.Arrays;

class Heap{
    private int[] array;
   private int size;
    Heap(){
        this(new int[0]);
    }
    Heap(int[] array){
        this.array=new int[10000];
        for(int i=0;i<array.length;i++){
            this.array[i]=array[i];
        }
        this.size=array.length;
        createHeap(this.array,this.size);
    }

    /**
     *
     * @return 返回最值
     */
    int top(){
        return array[0];
    }

    //删除堆顶元素，然后让最后一个元素赋值给堆顶，然后向下调整
    int pop(){
        int v=array[0];
        array[0]=array[this.size-1];
        this.size--;
        heapify(array,size,0);
        return v;
    }
    //在最后一个位置的后面添加堆元素，然后向上调整
    void push(int v){
        array[size++]=v;
        adjustUp(array,size,size-1);
    }
    //获取堆中元素的个数
    public int getSize(){
        return this.size;
    }
       //大堆
    private void adjustUp(int[] array, int size, int index) {
        /**
         * 1.array[index]<=array[(index-1)/2]比不过双亲结点的值
         * 2.index==0
         */
        while(index>0){
              int parent=(index-1)/2;
              if(array[parent]>=array[index]){
                  break;
              }
              //交换
            int t=array[parent];
            array[parent]=array[index];
            array[index]=t;
            //继续向上调整
            index=parent;
        }

    }

    /**
     * 大堆
     * 向下调整（堆化）
     * 必须满足可以向下调整的前提：只有一个位置不满足堆
     *
     * @param tree  看成完全二叉树的下标
     * @param index 要调整的下标
     */
    public  static void heapify(int[] tree, int size,int index) {
        /**
         * 1.判断index位置是不是叶子结点
         * 完全二叉树，只要判断有没有左孩子
         * 转化为数组下标越界的问题去判断
         */
        int left = 2 * index + 1;
        if (left >= size) {
            return;
        }
        /**
         * 不是叶子结点，意味着一定有左孩子，但不一定有右孩子
         * 2.找到最大的一个孩子
         *      1）没有右孩子  左孩子最大
         *      2）有右孩子
         *              左边大  左孩子大
         *              右边大  右孩子大
         */
        int right = 2 * index + 2;
        int max = left;
        if (right < size && tree[right] > tree[left]) {//，只有下标没有越界，才能访问数组的值
            max = right;
        }
        /**
         * 3.和要调整的结点的值进行比较
         * 如果要调整的结点值比较大，满足堆的性质，不需要调整
         * 否则，交换数组中两个下标的值
         * 并且，继续以max作为下标，进行向下调整
         */
        if (tree[index] >= tree[max]) {
            return;
        }
        //根的值较小，先交换
        int t = tree[max];
        tree[max] = tree[index];
        tree[index] = t;
        //继续向下调整
        heapify(tree, size,max);
    }

    //建堆 细算：O(n)  粗略：O(n*log(n))
    public static void createHeap(int[] array,int size) {
        //从最后一个非叶子结点的下标开始，一路向下调整至根位置。[(array.length-2)/2,0]
        for (int i = (size - 2) / 2; i >= 0; i--) {
            heapify(array, size,i);
        }
    }
  
}

 

寻瀑
关注
专栏目录
数据结构——堆
qq_49912778的博客
03-20 9844
1.堆的定义 堆（heap）是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵完全二叉树(逻辑层面上)的数组对象(物理层面上),常用来在一组变化频繁(发生增删查改的频率较高)的数据中寻找最值.将根结点最大的堆叫做最大堆或大根堆，这样可以找到堆中的最大值(根节点的值);根结点最小的堆叫做最小堆或小根堆,这样可以找到堆中的最小值。 2.堆在物理上和逻辑上的相互转换 3.堆的核心操作——向下调整 要实现向下调整,需要满足的前提是:针对某个结点...
数据结构与算法学习---数据结构篇（堆）（默然回首，夯实基础）
weixin_43185348的博客
05-26 268
一、堆 1.1 堆的定义 堆是计算机科学中一类特殊的数据结构的统称，堆通常可以被看做是一棵完全二叉树的数组对象。 堆的特性： 1.它是完全二叉树，除了树的最后一层结点不需要是满的，其它的每一层从左到右都是满的，如果最后一层结点不是满的，那么要求左满右不满。 2.它通常用数组来实现。 具体方法就是将二叉树的结点按照层级顺序放入数组中，根结点在位置1，它的子结点在位置2和3，而子结点的子结点则分别在位置4,5,6和7，以此类推。 如果一个结点的位置为k，则它的父结点的位置为[k/2],而它的两个子结点的位置
数据结构--经典排序之选择排序（超详细！！）
最新发布
2301_79381549的博客
09-04 958
它的工作原理是，首先在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。.如果在交换之前，max恰好是begin，那么由于begin位置的值已经被交换出去，我们需要更新max为min的位置。.接着，我们使用Swap函数将begin位置的值与最小值进行交换，这样确保了begin位置始终是已排序的最小值。.Swap 函数是一个简单的值交换函数，它接受两个整数的指针，并交换它们所指向的值。
数据结构：堆 的详解
潜心钻研技术
09-05 7290
堆 文章目录堆堆的概念及结构堆的性质堆的实现向下调整算法（小根堆）代码向上排序算法代码堆的创建堆的增加元素堆减少元素堆的应用堆排序TopK问题 堆的概念及结构 如果有一个关键码的集合k={k0,k1,k2…,kn-1}，把他们的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki<K(2i+1) 且 Ki<=K(2i+2) (或Ki>=K(2i+1) 且Ki>=K (2i+2) ) i=1,2,…，则称为小堆（大堆）。将根节点最大的堆叫做对大堆或大根堆，根节点最小
数据结构之堆
亦是远方的小地方
09-29 2427
数据结构；南京邮电大学811数据结构；计算机考研；
数据结构-堆的定义描述
weixin_30481087的博客
03-13 146
堆是什么？ 它是一种树形组织，使我们能迅速确定包含最大值（或最小值）的结点。 具体来说，堆是一颗左平衡的二叉树。随着结点的增加，树会逐级从左到右增长。 （左平衡是指，如果一棵平衡树的最后一层的所有叶子结点都在最靠左边的位置上，则称这棵树是左平衡的。） 顺序特点 堆状态的二叉树是“局部有序”的，任何一个结点与其兄弟结点之间都没有必然的顺序关系，但它与其父子结点有大小顺序关系。 堆的分类 ...
Python数据结构与算法之完全树与最小堆实例
09-21
**完全二叉树**作为数据结构的一种，能够有效地支持多种操作，而**最小堆**则是完全二叉树的一种特殊形式，广泛应用于优先队列和其他需要快速查找最小元素的场景中。掌握这些基本的数据结构与算法对于软件开发非常...
STL_quene.rar_crowd7oc_优先队列 堆_大根堆_大根对 c++_小根堆
09-24
首先，大根堆和小根堆是堆数据结构的两种常见类型。堆通常是一个完全二叉树，其中每个父节点的值都大于或等于其子节点的值（大根堆），或者小于或等于其子节点的值（小根堆）。这种特性使得堆的根节点始终是最大值或...
C++二叉堆实现.zip
08-20
在C++中，我们可以自定义二叉堆的数据结构并实现相关操作，如插入元素、删除最小/最大元素、调整堆等。 在给定的压缩包文件"C++二叉堆实现.zip"中，包含了两个文件：MyBinaryHeapTest.cpp 和 MyBinaryHeap.h。这...
数据结构堆排序MFC实现
05-25
在数据结构中，堆通常被定义为一个近似完全二叉树的结构，并且满足堆属性：父节点的键值总是大于或等于（最大堆）或小于或等于（最小堆）其子节点的键值。这种排序方法由Josephus Findlay于1964年提出，由于其效率较...
fastheap:Go（golang）中的快速堆数据结构
05-04
总之，快速堆是数据结构和算法的重要组成部分，理解其工作原理并在Go中实现它可以帮助你提升编程技能，更好地解决复杂问题。通过研究`fastheap-master`项目，你可以深入学习到如何在Go语言环境中设计和优化数据结构...
堆的定义
qq_44256227的博客
05-13 2438
堆定义操作的时间复杂度1.普通数组2.有序数组3.普通链表4.有序链表性质最大堆和最小堆堆结构 定义 我们知道，队列的特点是“先进先出“，但如果队列中的某些元素需要先出即“插队”的话，队列无法满足这种要求，于是提出了堆的概念。 堆也称为“优先队列”，是一种特殊的队列，从堆中取出元素是依照元素的优先级大小，而不是进入队列的先后顺序。 操作的时间复杂度 1.普通数组 插入的时间复杂度为O(1)，删除元...
数据结构之堆的定义
热门推荐
程序员想事儿
07-11 2万+
基本概念 堆是一种基本的数据结构。在这里我用数组来形容，在一个二叉堆的数组中，每一个元素都要保证大于等于另外两个特定位置的元素。同时相应的，这些元素又要大于等于另外两个相应位置的元素，整个数据结构以此类推。如果我们将整个数据结构画成树状结构，就能够清晰地看出整个结构的样子。 图片中显示的是最大堆和最小堆，两者的原理近似，这里我们讨论最大堆的实现。当一颗二叉树的每个结点都大于等于它的两个子节点时
堆（数据结构）
zgdlxs的博客
01-24 2万+
1.堆的概念 如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<=K2i+2 ，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。除了最后一层以外上面的节点但是非空的，最后一层节点是从左到右依次排布的。如图： ...
数据结构——【堆】
m0_69323023的博客
09-12 7092
堆
数据结构-堆
weixin_40323532的博客
03-10 1224
堆（英语：heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。堆中某个节点的值必须大于等于或者小于等于子节点的值堆总是一棵完全二叉树。1大顶堆：结点的值大于等于子节点的值2小顶堆：结点的值小于等于子节点的值常见的堆有二叉堆、斐波那契堆等。
堆排序关键详解：建堆与调整方法
数据类型通常指的是预定义的基本类型，如整数、字符等，而ADT则更广泛，允许用户自定义数据结构及其操作。ADT由值域、一组定义在其上的操作组成，强调抽象和信息隐蔽，即隐藏数据的底层实现细节，仅提供用户友好的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值