二叉堆 c++

最新推荐文章于 2022-11-27 22:35:52 发布
最新推荐文章于 2022-11-27 22:35:52 发布
阅读量142 收藏
点赞数
分类专栏： C++ 文章标签： 二叉堆
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37964922/article/details/103308286
版权

 https://www.cnblogs.com/skywang12345/p/3610382.html

/**
 * 二叉堆(最大堆)
 *
 * @author skywang
 * @date 2014/03/07
 */

#include <iomanip>
#include <iostream>
using namespace std;

template <class T>
class MaxHeap{
    private:
        T *mHeap;        // 数据
        int mCapacity;    // 总的容量
        int mSize;        // 实际容量

    private:
        // 最大堆的向下调整算法
        void filterdown(int start, int end);
        // 最大堆的向上调整算法(从start开始向上直到0，调整堆)
        void filterup(int start);
    public:
        MaxHeap();
        MaxHeap(int capacity);
        ~MaxHeap();

        // 返回data在二叉堆中的索引
        int getIndex(T data);
        // 删除最大堆中的data
        int remove(T data);
        // 将data插入到二叉堆中
        int insert(T data);
        // 打印二叉堆
        void print();
};

/* 
 * 构造函数
 */
template <class T>
MaxHeap<T>::MaxHeap()
{
    new (this)MaxHeap(30);
}

template <class T>
MaxHeap<T>::MaxHeap(int capacity)
{
    mSize = 0;
    mCapacity = capacity;
    mHeap = new T[mCapacity];
}
/* 
 * 析构函数
 */
template <class T>
MaxHeap<T>::~MaxHeap() 
{
    mSize = 0;
    mCapacity = 0;
    delete[] mHeap;
}

/* 
 * 返回data在二叉堆中的索引
 *
 * 返回值：
 *     存在 -- 返回data在数组中的索引
 *     不存在 -- -1
 */
template <class T>
int MaxHeap<T>::getIndex(T data)
{
    for(int i=0; i<mSize; i++)
        if (data==mHeap[i])
            return i;

    return -1;
}

/* 
 * 最大堆的向下调整算法
 *
 * 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 *
 * 参数说明：
 *     start -- 被下调节点的起始位置(一般为0，表示从第1个开始)
 *     end   -- 截至范围(一般为数组中最后一个元素的索引)
 */
template <class T>
void MaxHeap<T>::filterdown(int start, int end)
{
    int c = start;          // 当前(current)节点的位置
    int l = 2*c + 1;     // 左(left)孩子的位置
    T tmp = mHeap[c];    // 当前(current)节点的大小

    while(l <= end)
    {
        // "l"是左孩子，"l+1"是右孩子
        if(l < end && mHeap[l] < mHeap[l+1])
            l++;        // 左右两孩子中选择较大者，即mHeap[l+1]
        if(tmp >= mHeap[l])
            break;        //调整结束
        else
        {
            mHeap[c] = mHeap[l];
            c = l;
            l = 2*l + 1;   
        }       
    }   
    mHeap[c] = tmp;
}

/*
 * 删除最大堆中的data
 *
 * 返回值：
 *      0，成功
 *     -1，失败
 */
template <class T>
int MaxHeap<T>::remove(T data)
{
    int index;
    // 如果"堆"已空，则返回-1
    if(mSize == 0)
        return -1;

    // 获取data在数组中的索引
    index = getIndex(data); 
    if (index==-1)
        return -1;

    mHeap[index] = mHeap[--mSize];    // 用最后元素填补
    filterdown(index, mSize-1);        // 从index位置开始自上向下调整为最大堆

    return 0;
}

/*
 * 最大堆的向上调整算法(从start开始向上直到0，调整堆)
 *
 * 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 *
 * 参数说明：
 *     start -- 被上调节点的起始位置(一般为数组中最后一个元素的索引)
 */
template <class T>
void MaxHeap<T>::filterup(int start)
{
    int c = start;            // 当前节点(current)的位置
    int p = (c-1)/2;        // 父(parent)结点的位置 
    T tmp = mHeap[c];        // 当前节点(current)的大小

    while(c > 0)
    {
        if(mHeap[p] >= tmp)
            break;
        else
        {
            mHeap[c] = mHeap[p];
            c = p;
            p = (p-1)/2;   
        }       
    }
    mHeap[c] = tmp;
}
  
/* 
 * 将data插入到二叉堆中
 *
 * 返回值：
 *     0，表示成功
 *    -1，表示失败
 */
template <class T>
int MaxHeap<T>::insert(T data)
{
    // 如果"堆"已满，则返回
    if(mSize == mCapacity)
        return -1;
 
    mHeap[mSize] = data;        // 将"数组"插在表尾
    filterup(mSize);    // 向上调整堆
    mSize++;                    // 堆的实际容量+1

    return 0;
}
  
/* 
 * 打印二叉堆
 *
 * 返回值：
 *     0，表示成功
 *    -1，表示失败
 */
template <class T>
void MaxHeap<T>::print()
{
    for (int i=0; i<mSize; i++)
        cout << mHeap[i] << " ";
}
    
int main()
{
    int a[] = {10, 40, 30, 60, 90, 70, 20, 50, 80};
    int i, len=(sizeof(a)) / (sizeof(a[0])) ;
    MaxHeap<int>* tree=new MaxHeap<int>();

    cout << "== 依次添加: ";
    for(i=0; i<len; i++)
    {
        cout << a[i] <<" ";
        tree->insert(a[i]);
    }

    cout << "\n== 最 大 堆: ";
    tree->print();

    i=85;
    tree->insert(i);
    cout << "\n== 添加元素: " << i;
    cout << "\n== 最 大 堆: ";
    tree->print();

    i=90;
    tree->remove(i);
    cout << "\n== 删除元素: " << i;
    cout << "\n== 最 大 堆: ";
    tree->print();
    cout << endl; 

    return 0;
}
/**
 * 二叉堆(最小堆)
 *
 * @author skywang
 * @date 2014/03/07
 */

#include <iomanip>
#include <iostream>
using namespace std;

template <class T>
class MinHeap{
    private:
        T *mHeap;        // 数据
        int mCapacity;    // 总的容量
        int mSize;        // 实际容量

    private:
        // 最小堆的向下调整算法
        void filterdown(int start, int end);
        // 最小堆的向上调整算法(从start开始向上直到0，调整堆)
        void filterup(int start);
    public:
        MinHeap();
        MinHeap(int capacity);
        ~MinHeap();

        // 返回data在二叉堆中的索引
        int getIndex(T data);
        // 删除最小堆中的data
        int remove(T data);
        // 将data插入到二叉堆中
        int insert(T data);
        // 打印二叉堆
        void print();
};

/* 
 * 构造函数
 */
template <class T>
MinHeap<T>::MinHeap()
{
    new (this)MinHeap(30);
}

template <class T>
MinHeap<T>::MinHeap(int capacity)
{
    mSize = 0;
    mCapacity = capacity;
    mHeap = new T[mCapacity];
}
/* 
 * 析构函数
 */
template <class T>
MinHeap<T>::~MinHeap() 
{
    mSize = 0;
    mCapacity = 0;
    delete[] mHeap;
}

/* 
 * 返回data在二叉堆中的索引
 *
 * 返回值：
 *     存在 -- 返回data在数组中的索引
 *     不存在 -- -1
 */
template <class T>
int MinHeap<T>::getIndex(T data)
{
    for(int i=0; i<mSize; i++)
        if (data==mHeap[i])
            return i;

    return -1;
}

/* 
 * 最小堆的向下调整算法
 *
 * 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 *
 * 参数说明：
 *     start -- 被下调节点的起始位置(一般为0，表示从第1个开始)
 *     end   -- 截至范围(一般为数组中最后一个元素的索引)
 */
template <class T>
void MinHeap<T>::filterdown(int start, int end)
{
    int c = start;          // 当前(current)节点的位置
    int l = 2*c + 1;     // 左(left)孩子的位置
    T tmp = mHeap[c];    // 当前(current)节点的大小

    while(l <= end)
    {
        // "l"是左孩子，"l+1"是右孩子
        if(l < end && mHeap[l] > mHeap[l+1])
            l++;        // 左右两孩子中选择较小者，即mHeap[l+1]
        if(tmp <= mHeap[l])
            break;        //调整结束
        else
        {
            mHeap[c] = mHeap[l];
            c = l;
            l = 2*l + 1;   
        }       
    }   
    mHeap[c] = tmp;
}
 
/*
 * 删除最小堆中的data
 *
 * 返回值：
 *      0，成功
 *     -1，失败
 */
template <class T>
int MinHeap<T>::remove(T data)
{
    int index;
    // 如果"堆"已空，则返回-1
    if(mSize == 0)
        return -1;

    // 获取data在数组中的索引
    index = getIndex(data); 
    if (index==-1)
        return -1;

    mHeap[index] = mHeap[--mSize];        // 用最后元素填补
    filterdown(index, mSize-1);    // 从index号位置开始自上向下调整为最小堆

    return 0;
}

/*
 * 最小堆的向上调整算法(从start开始向上直到0，调整堆)
 *
 * 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 *
 * 参数说明：
 *     start -- 被上调节点的起始位置(一般为数组中最后一个元素的索引)
 */
template <class T>
void MinHeap<T>::filterup(int start)
{
    int c = start;            // 当前节点(current)的位置
    int p = (c-1)/2;        // 父(parent)结点的位置 
    T tmp = mHeap[c];        // 当前节点(current)的大小

    while(c > 0)
    {
        if(mHeap[p] <= tmp)
            break;
        else
        {
            mHeap[c] = mHeap[p];
            c = p;
            p = (p-1)/2;   
        }       
    }
    mHeap[c] = tmp;
}
  
/* 
 * 将data插入到二叉堆中
 *
 * 返回值：
 *     0，表示成功
 *    -1，表示失败
 */
template <class T>
int MinHeap<T>::insert(T data)
{
    // 如果"堆"已满，则返回
    if(mSize == mCapacity)
        return -1;
 
    mHeap[mSize] = data;        // 将"数组"插在表尾
    filterup(mSize);            // 向上调整堆
    mSize++;                    // 堆的实际容量+1

    return 0;
}
  
/* 
 * 打印二叉堆
 *
 * 返回值：
 *     0，表示成功
 *    -1，表示失败
 */
template <class T>
void MinHeap<T>::print()
{
    for (int i=0; i<mSize; i++)
        cout << mHeap[i] << " ";
}

int main()
{
    int a[] = {80, 40, 30, 60, 90, 70, 10, 50, 20};
    int i, len=(sizeof(a)) / (sizeof(a[0])) ;
    MinHeap<int>* tree=new MinHeap<int>();

    cout << "== 依次添加: ";
    for(i=0; i<len; i++)
    {
        cout << a[i] <<" ";
        tree->insert(a[i]);
    }

    cout << "\n== 最 小 堆: ";
    tree->print();

    i=15;
    tree->insert(i);
    cout << "\n== 添加元素: " << i;
    cout << "\n== 最 小 堆: ";
    tree->print();

    i=10;
    tree->remove(i);
    cout << "\n== 删除元素: " << i;
    cout << "\n== 最 小 堆: ";
    tree->print();
    cout << endl; 

    return 0;
}

 

菜鸟&攻城狮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉堆c++代码
03-23
c++实现的二叉堆，很好的编程规范，可以学到模板、inline函数、引用的实际应用。代码写的很简洁
C++二叉堆实现.zip
08-20
在C++中，我们可以自定义二叉堆的数据结构并实现相关操作，如插入元素、删除最小/最大元素、调整堆等。 在给定的压缩包文件"C++二叉堆实现.zip"中，包含了两个文件：MyBinaryHeapTest.cpp 和 MyBinaryHeap.h。这...
c++ 二叉堆
KonjakuLAF的博客
04-18 250
二叉堆的性质 编号 性质 1 二叉堆是一棵完全二叉树 2 二叉堆的任意一个节点的优先级一定大于其两个子节点的 3 如果一个节点的下标为 x ，则其左孩子的下标为 2x ，右孩子的下标为 2x+1 操作和时间复杂度 操作 时间复杂度 插入 \(O(\log n)\) 弹出 \(O(\log n)\) 获取极值 \(O(1)\) 上表可以看出二...
C/C++ 二叉堆
我想天胡啊啊啊的博客
04-02 1374
二叉堆是一棵满足“堆性质”的完全二叉树。以小根堆为例，其“堆性质”是指：树上每个结点的权值都小于等于其左右子节点的权值。（大根堆则反之） 根据完全二叉树的性质，可在存储时令下标为x的结点的左子结点下标为2x，右子结点下标为2x+1。 以小根堆为例，分别进行插入（Insert）、移除堆顶（Extract）、移除任意结点（Remove）操作。 # include <bits/stdc++.h> using namespace std; const int INF = ~(1<<31)
二叉堆（c++实现）
weixin_41009689的博客
05-17 848
二叉堆的介绍 二叉堆是完全二元树或者是近似完全二元树，按照数据的排列方式可以分为两种：最大堆和最小堆。 最大堆：父结点的键值总是大于或等于任何一个子节点的键值；最小堆：父结点的键值总是小于或等于任何一个子节点的键值。示意图如下： 二叉堆一般都通过"数组"来实现。数组实现的二叉堆，父节点和子节点的位置存在一定的关系。有时候，我们将"二叉堆的第一个元素"放在数组索引0的位置，有时候放在1的位置。当然，它们的本质一样(都是二叉堆)，只是实现上稍微有一点点的区别。 假设"第一个元素"在数组中的索引为 0 的话，则
C++实现二叉堆
chczy1的博客
11-04 442
#include using namespace std; #define MAXZ 100 #define RES 10 class heap { int *T; int cap; int len; public: heap(); heap(int); ~heap(); void up(int); void down(int,int); void interts(int);
SuanFan.zip_A二叉堆_A星 二叉堆_C++_c++11 a星算法_二叉堆
09-20
在本文中，我们将深入探讨A*（A星）算法及其与二叉堆的结合使用，特别是在C++编程语言中的实现。A*算法是一种在图中寻找最短路径的搜索算法，而二叉堆则是一种高效的优先队列数据结构，常用于优化路径查找过程。 ...
二叉堆.zip
最新发布
04-24
算法是解决特定问题或执行特定任务的一系列步骤或规则的有序集合。在计算机科学中，算法通常用来指导计算机执行特定的任务或解决问题。良好设计的算法能够有效地解决问题，并且在给定的输入下能够产生正确的输出。...
二叉堆的概念及其应用.pptx
07-21
二叉堆的概念及其应用，里面包含果子合并、堆排序、鱼塘钓鱼、最小函数值、Sequence等重要题型的详细解析
使用C++实现二叉堆
FS's Home
12-26 1596
二叉堆可以用来实现优先队列。二叉堆是一棵完全二叉树，除了叶子节点那一层，其他的层都是满的，叶子节点那一层是从左往右依次存放的，因此它们的父子元素的索引有数学公式可以参考，对于节点i来说，它的左儿子是2i，右儿子是2i+1，它的父亲节点是i/2向下取整，因此，在其内部我们可以通过数组来实现元素的存储，从而不需要链式结构，可以节约存储空间，提高访问速度（但是如果有合并操作，则会很慢，此时使用链式结构是
C++二叉堆实现A*算法及方向优化
01-20
由两部分组成，my_map.cpp用OpenCV实现读取地图等图像处理操作，main.cpp实现A*算法。二叉堆为类，格子为结构体。生成结果后进行优化，使原本只能走8个方向的结果优化为任意角度和方向，也就是真正的全局最短路径。
二叉堆的实现
04-18
二叉堆的C++实现，包含二叉堆的构造，插入，删除，销毁等操作
二叉堆：最小堆
07-08
使用c++实现最小堆。提供常见操作，如堆化数组，插入，删除，堆排序，遍历堆。
二叉堆的c++实现
weixin_42405632的博客
03-04 266
/************************************************************************ &amp;gt; File Name: BinaryHeap.cpp &amp;gt; Author: wpf &amp;gt; Mail: wpf9264@163.com &amp;gt; Created Time: 2019年03月04日 星期一...
二叉堆原理及实现(C++)
baidu_36161424的博客
05-28 976
文章目录一、二叉堆简介二、二叉堆的实现2.1 基本定义2.2 堆的插入2.3 堆的删除 一、二叉堆简介 二叉堆是完全二元树或者是近似完全二元树，按照数据的排列方式可以分为两种：大根堆和小根堆。 大根堆：父节点键值总是大于等于任何一个子节点键值 小根堆：父节点键值总是小于等于任何一个子节点键值 性质： 索引为i的左孩子的索引是 (2*i+1); 索引为i的右孩子的索引是 (2*i+2); 索引为i...
用C++写二叉堆（优先队列）代码，详细注释
m0_56222998的博客
11-27 636
用C++自己编写二叉堆代码
二叉堆C++实现
qq_18431031的博客
08-03 250
堆是一棵被完全填满的二叉树，有可能的例外是在底层，底层上的元素从左到右填入。这样的树称为完全二叉树。完全二叉树的高度为logN下取整。在堆中，对于每一个节点X，X的parent中的关键字小于（或等于）X中的关键字，根节点除外。 ...
C++二叉堆实现
liufangping的博客
10-08 215
heap并不属于标准库的内容，这里主要提供push_heap、pop_head、sort_heap、make_heap几个泛型算法，它们接受一对迭代器和一个权值比较规则，对底层容器中迭代器范围内的元素进行相应操作，从而维持底层容器堆的特性 代码实现：https://github.com/inmail/mySTL/blob/master/mySTL/9stl_heap.h ...
C++STL之二叉堆
weixin_34080571的博客
01-15 477
2019独角兽企业重金招聘Python工程师标准>>> ...
c++ 二叉堆 duildheap
05-31
二叉堆是一种经典的数据结构，可以用来实现优先队列等数据结构。二叉堆分为最大堆和最小堆两种形式，本文以最大堆为例介绍如何实现二叉堆的建堆操作 buildHeap()。 二叉堆可以用数组来表示，具体来说，如果一个节点...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值