大顶堆删除最大值_第8篇:C++ 数据结构-最大堆

最新推荐文章于 2023-11-14 13:09:04 发布
最新推荐文章于 2023-11-14 13:09:04 发布
阅读量322 收藏
点赞数
文章标签： 大顶堆删除最大值
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_33768246/article/details/112063183
版权

MaxHeap类接口定义

最大堆的类接口定义，我们命名为MaxHeap，如下代码所示

#ifndef __MAXHEAP_HH__
#define __MAXHEAP_HH__
#include <iostream>
#include <limits>
#include "./Heap.hh"

template<class T>
class MaxHeap:public Heap<T>{

private:
    //泛型T中的最大值
    const T NUM_MAX=std::numeric_limits<T>::max();

    //元素值上浮操作
    void shiftUp(int i);

    //数值
    void increase(int,T);

    //最小堆所有节点重排序
    void max_heapify(int,int);

    void max_heapify(int);

    void init_heap(int);
public:
    MaxHeap();
    MaxHeap(const T*,int);

    void insert(T);

    void removeAt(int);

    T get_max();

    T get_min();

    T extractMax();
    
    template<typename R>
    friend std::ostream &operator<<(std::ostream &out,const MaxHeap<R> &hp);
};
#endif

二叉堆实例化的时间复杂度

我们需要考虑一下创建二叉堆的运行时间。像之前二叉树概念篇一样，这里对n做一些假设简化二叉堆模型。在这种情况下，最方便的假设是 n的形式为

，其中
是二叉堆的高度，并且二叉堆是一颗完美二叉树。初始化二叉堆的运行时间取决于二叉堆元素在heapify终止递归之前其最小值元素下沉的距离。 在最坏的情况下，从根节点到叶子节点的任意路径中的最小值的元素可能会一直下沉到叶子节点所在层。 我们逐层计算二叉堆的时间开销。
  • 在第
    层，有
    个节点，但是我们都不在其中任何一个叶子节点调用max_heapify，因此其开销为0。
  • 在第
    层开始，有
    个节点，每个节点可能会下沉1层,那么最差时间开销的情况
    。
  • 在第
    层开始，有
    个节点，每个节点可能会下沉2层,那么最差时间开销的情况
    。
  • 在第
    层开始，有
    个节点，每个节点可能会下沉3层,那么最差时间开销的情况
    。

.....

那么，泛化为一般情况，在第

层上，有
个节点，每个节点可能会下沉j层。那么最差时间开销的情况

因此，如果我们自下向上逐级计算，那么初始化整个二叉堆的时间复杂度是

即

,设该表达式A

这是我们分析最糟糕情况下，二叉堆的时间开销。 解上面表达式A的一个近似值，需要用到微积分的数学基础。

首先我们引入

时的无限一般几何级数的积分公式
，求其导数可知

然后对该导数两边乘

，可得
，设为表达式B

非常巧妙的是

,代入表达式B

,即
,和我们上面表达式A形式相近。

二叉堆模型的高度h逻辑上趋于

，从无限级数的积分可以
得到简单的近似值

, 即

因为

，即
，其简化形式如下

二叉堆实例化的时间复杂度

根据其上面的时间复杂度计算是一个接近

。对应的核心算法是max_heapify。MaxHeap构造函数中需要外层一个for循环遍历传入每个节点的索引到max_heapify方法中执行内部的排序操作。如下代码所示 
template<class T>
void MaxHeap<T>::init_heap(int n){
    //从最后一个非叶子节点的索引开始遍历
    for (int i = n/2-1; i>=0; i--){
        max_heapify(this->d_len,i);
    }
}
  • 步骤1:max_heapify(7,2):交换索引2和索引5之间的节点值
  • 步骤2:max_heapify(7,5) 立即退出。返回外部for循环。
  • 步骤3:max_heapify(7,1) 交换索引1和索引4之间的节点值
  • 步骤4:max_heapify(7,4) 立即退出。返回外部for循环。
  • 步骤5:max_heapify(7,0) 交换索引0和索引2之间的节点值
  • 步骤6:max_heapify(7,2) 交换索引2和索引6之间的节点值
  • 步骤7:max_heapify(7,4) 立即退出。返回外部for循环。

从上面的max_heapify演算如下图所示，实际上max_heapify在每次递归真正执行交换两个节点值的只有传入非叶子节点索引，例如步骤1、3、5、6。当传入叶子节点索引时函数栈的开销几乎是忽略不计的。换句话说不需要对叶子节点进行max_heapify操作。我们找到二叉堆中最后一个非叶节点（即内部节点）的位置，从第

层以自下向上顺序执行每个内部节点的heapify操作。

03a4c1a506acc4a75e3557566b0665f9.png

那么如何找到树中最后一个内部节点(即非叶子节点)呢？我们不妨来用下图来举例。我们知道图中两个是完整的二叉树，左图中最后一个内部节点是的索引是4,右图的最后一个内部节点是是3

5ca24333ccdfd6ad32fd0fb58b55cbd9.png

如果你自己动笔画出不同的完整二叉树形态，会总结到一个完整二叉树的特殊性质。

性质：完整二叉树的最后一个内部节点始终伴随着树中最后一个叶子节点，当然它可能是左子节点或右子节点。

也就是说,在n个节点的完整二叉树中，最后内部节点的索引我们用

表示，那么
表示最后一个节点的索引,那么他们的关系可以表示为

也就是说，我这里解释了为什么for循环为什么总是从n/2-1位置开始遍历二叉堆并调用max_heapify方法。

max_heapify算法实现

我们需要明确的是对于单个内部节点的max_heapify调用的时间复杂度是

,但由于外部循环调用的时间开销
,对于n个节点的二叉堆初始化的时间复杂度实际上也为
。 
template<class T>
void MaxHeap<T>::max_heapify(int n,int i){
    int L_IDX=2*i+1;
    int R_IDX=2*i+2;

    int LARGE_IDX=i;

    //如果左节点大于当前被标记的LARGE_IDX的节点,即更新当前LARGE_IDX为最新的L_IDX
    if(L_IDX<=n-1 && this->d_arr[L_IDX]>this->d_arr[LARGE_IDX])
        LARGE_IDX=L_IDX;
        
    //如果当右节点大于当前被标记的LARGE_IDX的节点,即更新当前LARGE_IDX为最新的R_IDX
    if(R_IDX<=n-1 && this->d_arr[R_IDX]>this->d_arr[LARGE_IDX])
        LARGE_IDX=R_IDX;
    
    if(LARGE_IDX!=i){
        swap(&(this->d_arr[i]),&(this->d_arr[LARGE_IDX]));
        max_heapify(n,LARGE_IDX);
    }
}

假设我们传入如下数组，目标是让其实例化一个最大堆。

d={1, 2, 6, 7, 9, 13, 10, 11, 8, 23, 42}

那么源数组的顺序逐个拷贝入二叉堆的内存会是如下图的起始状态。由于该树总节点数是11。最后一个非叶子节点索引=

。因此，最后一个内部节点的的元素值是9

我们仅对节点索引按逆序即[4、3、2、1、0]执行heapify操作。r如下图所示

51ee075acb576bf89bf4fcca928bd194.gif

构造函数

不论最大堆还是最小堆，完成整个对象的实例化其时间开销是 

template<class T>
MaxHeap<T>::MaxHeap(const T* data,int size):Heap<T>::Heap(data,size){
    if(this->d_arr!=nullptr){

        for (size_t i = 0; i < size; i++)
        {
            this->d_arr[i]=data[i];
        }
        this->d_len=size;
        init_heap(this->d_len);
    }
}

其他核心算法

template<class T>
void MaxHeap<T>::shiftUp(int i){
    //最大值上浮
    while(i!=0 && this->d_arr[this->parent(i)]<this->d_arr[i]){
        swap(&(this->d_arr[i]),&(this->d_arr[this->parent(i)]));
        i=this->parent(i);
    }
}

//将索引“i”处的键的值减小为新值。假定新值小于harr[i]
template<class T>
void MaxHeap<T>::increase(int k,T data){
    if(k<this->d_len){
        this->d_arr[k]=data;
        this->shiftUp(k);
    }else{
        std::cout<<""<<std::endl;
    }
}

剩下的算法其核心思想和最小堆是相同的，我就不说废话

插入操作

template<class T>
void MaxHeap<T>::insert(T data){
    if(this->d_len<this->d_capacity){
        this->d_len++;
        int k=this->d_len-1; //插入元素的位置
        this->d_arr[k]=data;
        
        if(k>=1){
            shiftUp(k);
        }
    }else{
        std::cout<<"无法插入新元素"<<std::endl;
    }
}

抽取最大值

template<class T>
T MaxHeap<T>::extractMax(){
    if(this->d_len==0){
        return NUM_MAX;
    }
    if(this->d_len==1){
        this->d_len--;
        return this->d_arr[0];
    }

    T r=this->d_arr[0];
    this->d_arr[0]=this->d_arr[this->d_len-1];
    this->d_len--;

    max_heapify(0);
    return r;
}

删除操作

template<class T>
void MaxHeap<T>::removeAt(int k){
    increase(k,NUM_MAX);
    extractMax();
}

其他辅助操作

template<class T>
T MaxHeap<T>::get_max(){
    return this->d_arr[0];
}

template<class T>
T MaxHeap<T>::get_min(){
    return this->d_arr[this->d_len-1];
}

template<typename R>
std::ostream &operator<<(std::ostream &out,const MaxHeap<R> &hp){
    out<<"[";
    for(auto i=0;i<hp.d_len-1;i++){
        out<<hp.d_arr[i]<<",";
    }

    int e=hp.d_len-1;

    out<<*(hp.d_arr+e)<<"]";
    return out;
}

代码测试：

#include <iostream>
#include "libs/MaxHeap.cpp"

int main()
{
    int a[11]={1,2,6,7,9,13,10,11,8,23,42};
    MaxHeap<int> m=MaxHeap<int>(a,11); 
    std::cout<<"高度:"<<m.height()<<std::endl;
    std::cout<<"节点数:"<<m.length()<<std::endl;
    std::cout<<"最大节点数:"<<m.capacity()<<std::endl;

    std::cout<<m<<std::endl;
    
    for (size_t i =0; i <m.length(); i++)
    {
        std::cout<<"Index:"<<i<<": "<<m[i]<<"  左节点  "<<m[m.lIndex(i)]
             <<" 右节点:"<<m[m.rIndex(i)]<<std::endl;
    }

    std::cout<<"删除节点5:"<<m[5]<<std::endl;
    m.removeAt(5);
    std::cout<<"节点数:"<<m.length()<<std::endl;
    std::cout<<m<<std::endl;

    std::cout<<"删除节点5:"<<m[5]<<std::endl;
    m.removeAt(5);
    std::cout<<"节点数:"<<m.length()<<std::endl;

    for (size_t i =0; i <m.length(); i++)
    {
        std::cout<<"Index:"<<i<<": "<<m[i]<<"  左节点  "<<m[m.lIndex(i)]
             <<" 右节点:"<<m[m.rIndex(i)]<<std::endl;
    }

    std::cout<<"高度:"<<m.height()<<std::endl;
    std::cout<<"节点数:"<<m.length()<<std::endl;
    std::cout<<"最大节点数:"<<m.capacity()<<std::endl;
    std::cout<<m<<std::endl;

    std::cout<<"最大值:"<<m.get_max()<<std::endl;
    std::cout<<"最小值:"<<m.get_min()<<std::endl;

    return 0;
}

程序输出

高度:3
节点数:11
最大节点数:15
[42,23,13,11,9,6,10,7,8,2,1]
Index:0: 42 左节点 23 右节点:13
Index:1: 23 左节点 11 右节点:9
Index:2: 13 左节点 6 右节点:10
Index:3: 11 左节点 7 右节点:8
Index:4: 9 左节点 2 右节点:1
Index:5: 6 左节点 0 右节点:0
Index:6: 10 左节点 0 右节点:0
Index:7: 7 左节点 0 右节点:0
Index:8: 8 左节点 0 右节点:0
Index:9: 2 左节点 0 右节点:0
Index:10: 1 左节点 0 右节点:0
删除节点5:6
节点数:10
[42,23,13,11,9,1,10,7,8,2]
删除节点5:1
节点数:9
Index:0: 42 左节点 23 右节点:13
Index:1: 23 左节点 11 右节点:9
Index:2: 13 左节点 2 右节点:10
Index:3: 11 左节点 7 右节点:8
Index:4: 9 左节点 0 右节点:0
Index:5: 2 左节点 0 右节点:0
Index:6: 10 左节点 0 右节点:0
Index:7: 7 左节点 0 右节点:0
Index:8: 8 左节点 0 右节点:0
高度:3
节点数:9
最大节点数:15
[42,23,13,11,9,2,10,7,8]
最大值:42
最小值:8

总结：

我们用了3篇的来讨论了二叉堆的几乎所有特性，还有一个优先队列的数据结构，它是基于最大堆或最小堆构建的。笔者没兴趣再写。有兴趣的读者请自行实现。

下一篇，有空时在更新二叉查找树(Binary Search Tree)的有关话题。

曾姐问答
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
用c++实现最大堆（插入、删除、读取堆顶元素）
qq_43128219的博客
05-21 1313
用数组来实现堆，数组序号为0的元素即为堆顶。 插入：将数据放到数组的最后，然后向上渗透。 删除堆顶：将数组最后一个元素替换堆顶，然后向下渗透。 头文件MaxHeap.h #ifndef _MAX_HEAP_ #define _MAX_HEAP_ template <class T> class MaxHeap { public: MaxHeap(int mx = 10); //默认堆的最大值为10 virtual ~MaxHeap(); bool IsEmpty(); //判断堆是否为
C++之常见顶堆问题汇总
最新发布
03-05
顶堆是一种特殊的树形数据结构，其中每个父节点的关键值要么大于（对于大顶堆）或小于（对于小顶堆）它的子节点的关键值。这种性质使得堆的顶部（根节点）始终包含最大或最小的元素，这为快速访问最大或最小元素提供...
大顶堆删除最大值_(59)C++面试之队列最大值
weixin_31608241的博客
11-21 107
// 面试题59（一）：滑动窗口的最大值// 题目：给定一个数组和滑动窗口的大小，请找出所有滑动窗口里的最大值。例如，// 如果输入数组{2, 3, 4, 2, 6, 2, 5, 1}及滑动窗口的大小3，那么一共存在6个// 滑动窗口，它们的最大值分别为{4, 4, 6, 6, 6, 5}，第一种解答：#include <iostream> #include <vector&gt...
[C++]数据结构：最大堆MaxHeap的创建与使用
thewebcode
12-08 477
优先队列是一种非常常见的数据结构， 而最大最小树又是其中最具代表性的一种优先队列。 在此详细的讲述一下最大树的插入、删除、初始化等基本操作的思路。 在文章最后附上一段Demo源码提供测试，使用C++语言实现了最大堆。 首先先介绍一下最大树的概念。 最大树是每个节点的值都要大于或等于其子节点的值的树。 而最大堆就是最大的完全二叉树。 因为最大堆是完全二叉树，所以拥有n个元素的堆的高度为...
C++实现大顶堆的插入删除操作
qiexinyueaifei的博客
11-16 394
其实无论是大顶堆还是小顶堆，会了一个就会另外一个的写法了，这个其实并不难写，我的理解是：所谓插入其实就是往上渗透，所谓删除其实就是往下渗透，他们都是在找最后一个点的合理位置！下面直接上代码了，相关解释都在注释上： template<class T> class My_Heap{ public: My_Heap(int a = 10){ MaxSize = a; CurrentSize = 0; Array = new T[MaxSize]; } ~My_Heap(){ de
大顶堆删除最大值_C++｜使用STL算法创建、调整、输出最大堆、最小堆
weixin_39661780的博客
11-16 410
最大堆(又叫大根堆、大顶堆)和最小堆是二叉堆的两种形式，一类很重要的数据结构，如用于堆排序等。最小堆：根结点的键值是所有堆结点键值中最小者，且每个结点的值都比其孩子的值小。最大堆：根结点的键值是所有堆结点键值中最大者，且每个结点的值都比其孩子的值大。下面以大根堆为例，来说明其入堆和出堆的操作：入堆，插入：向上渗透(先是插入堆的最后位置，然后按最大堆的规则调整到适当位置)；出堆，删除：向下渗透(第一...
LeetCode解决方案：:white_medium_star:LeetCode解决方案按类别分组:white_medium_star:
01-30
例如，“Kth Largest Element in an Array”可以使用大顶堆找到数组中第k大的元素。 6. **回溯与剪枝**：这类问题通常要求找到所有可能的解，如“N-Queens”问题，使用回溯法可以有效地找出所有可行的皇后布局。 7...
学习数据结构堆.rar
07-19
9. **代码实现**：可能会包含用Python、C++或Java等编程语言实现的堆数据结构和相关操作的示例代码。 通过学习这个压缩包里的内容，你将能够掌握堆的基本概念，理解其工作原理，并能够用编程语言实现堆的各个操作。...
用C++实现数据结构中的各种算法
05-25
本文将详细介绍如何使用C++来实现数据结构中的各种算法，涉及的算法包括但不限于顺序表、单链表、双向循环链表、单项循环链表、顺序栈、链式栈、顺序队列、链式队列、优先级队列、串、二叉树、线索二叉树、堆、...
C/C++实现八大排序算法汇总
09-01
构建一个大顶堆，然后将堆顶元素（最大值）与末尾元素交换，然后重新调整堆，重复此过程，直到所有元素排序完毕。时间复杂度为O(n log n)，空间复杂度为O(1)。 - **计数排序**和**桶排序**：这两种是线性时间复杂度...
删数得最大数
11-24
【问题描述】 给定一个r位(r<1000)正整数C，去掉其中任意s个数字后将剩余的数字按原来的左右顺序组成一个新的正整数，使得新组成的数的值最大。 【输入形式】 从标准输入读入n+1行，其中第一行是正整数s(s<800)，以下n行是正整数C的各位数字，以及可能的空格符和换行符。 【输出形式】 将计算结果写到标准输出上，每50个数字一行，每5个数字之间由一个空格符分隔。 【输入样例1】 2 123 321
大顶堆删除最大值_C/C++后台开发学习笔记(九)-二叉堆
weixin_39522103的博客
12-10 145
首先恭喜您，能够阅读到这篇文章《二叉堆》，如果对部分理解不太明白，建议先将文章收藏起来，然后对不清楚的知识点进行查阅，然后在进行阅读，相应你会有更深的认知。如果您喜欢这篇文章，就点个赞或者【关注我】吧！一、二叉堆简介（1） 简介二叉堆本质上是一种完全二叉树，它分为两个类型。最大堆：任何一个父节点的值，都大于或等于它左右孩子结点的值。最小堆：任何一个父节点的值，都小于或等于它左右孩子结点的值。二叉堆...
删除最大值（C/C++实现）
m0_62600503的博客
04-16 4262
题目描述:输入10个互不相同的整数并保存在数组中，找到该最大元素并删除它，输出删除后的数组 都是运行通过的，Zero Error。 C： #include<stdio.h> int main() { int N = 10; int a[N],max = 0,temp; for (int i = 0; i < N; i++) {scanf("%d", &a[i]);}//输入 for (int i = 0; i < N; i++) { if (a[i] &
c++去掉最大最小值
HZYSX的博客
11-14 415
【代码】c++去掉最大最小值。
java maxheap_Java底层PriorityQueue 优先队列——基于MaxHeap最大堆
weixin_35529551的博客
02-16 149
1、什么是优先队列优先队列也是一种队列，它的接口函数和队列相同。public interface Queue {int getSize();boolean isEmpty();E dequeue();void enqueue(E e);E getFront();}虽然代码相同，需要注意的是，出队操作：拿出最大值(优先级最高)。但相对于普通的队列有着宏观上的不同。普通队列：先进先出，后进后出优先队列...
#7. 删除最大数
lizhuoqun111的博客
03-11 589
题目描述输入n个数，要求找出n个数的最大值，并将最大的数删除后，再输出剩余的数。提示，如果有多个最大的数，那么都要删除。如果一个数也不剩下，输出"none"输入格式第一行：n n
C++编程（数组） 去除最大值和最小值，评委的平均分。
热门推荐
Alex
06-02 1万+
#include "iostream" using namespace std; int main() { const int n=6; //灵活定义数组的大小 int a[n],max, min,i=0,sum; double score; for(i=0; i<n; i++) //灵活输入数组的元素 cin>>a[i]; //输出处理前的结果值：
c++数组排序，找最大值最小值，函数
weixin_37520565的博客
08-27 1324
void max_min(void* arr, const int arrLength, int** ptrArr) {//找最值 int* arr1 = (int*)arr; //int *ptrMax = nullptr; int* ptrMin = nullptr; if (*arr1 > * (arr1 + 1)) { //ptrArr[0]...
C++数据结构复习：栈的应用-逆序输出与进制转换
这篇复习笔记是作者结合谭浩强的《C++程序设计》、邓俊辉的《数据结构（C++语言版）》以及CSDN博客的资料编撰而成，旨在帮助C++初学者复习和应届生准备笔试面试。笔记内容分为C++基本知识和C++数据结构两大部分。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值