二叉堆 c++

最新推荐文章于 2024-07-29 13:57:19 发布
最新推荐文章于 2024-07-29 13:57:19 发布
阅读量167 收藏
点赞数
分类专栏： 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;
}

 

菜鸟&攻城狮
关注
专栏目录
c++实现二叉堆及堆排序
远走的兔子博客
05-28 3034
一、什么是二叉堆
二叉堆c++代码
03-23
c++实现的二叉堆，很好的编程规范，可以学到模板、inline函数、引用的实际应用。代码写的很简洁
c++ 二叉堆
KonjakuLAF的博客
04-18 275
二叉堆的性质 编号 性质 1 二叉堆是一棵完全二叉树 2 二叉堆的任意一个节点的优先级一定大于其两个子节点的 3 如果一个节点的下标为 x ，则其左孩子的下标为 2x ，右孩子的下标为 2x+1 操作和时间复杂度 操作 时间复杂度 插入 \(O(\log n)\) 弹出 \(O(\log n)\) 获取极值 \(O(1)\) 上表可以看出二...
C/C++ 二叉堆
我想天胡啊啊啊的博客
04-02 1407
二叉堆是一棵满足“堆性质”的完全二叉树。以小根堆为例，其“堆性质”是指：树上每个结点的权值都小于等于其左右子节点的权值。（大根堆则反之） 根据完全二叉树的性质，可在存储时令下标为x的结点的左子结点下标为2x，右子结点下标为2x+1。 以小根堆为例，分别进行插入（Insert）、移除堆顶（Extract）、移除任意结点（Remove）操作。 # include <bits/stdc++.h> using namespace std; const int INF = ~(1<<31)
二叉堆（c++实现）
weixin_41009689的博客
05-17 905
二叉堆的介绍 二叉堆是完全二元树或者是近似完全二元树，按照数据的排列方式可以分为两种：最大堆和最小堆。 最大堆：父结点的键值总是大于或等于任何一个子节点的键值；最小堆：父结点的键值总是小于或等于任何一个子节点的键值。示意图如下： 二叉堆一般都通过"数组"来实现。数组实现的二叉堆，父节点和子节点的位置存在一定的关系。有时候，我们将"二叉堆的第一个元素"放在数组索引0的位置，有时候放在1的位置。当然，它们的本质一样(都是二叉堆)，只是实现上稍微有一点点的区别。 假设"第一个元素"在数组中的索引为 0 的话，则
C++实现二叉堆
chczy1的博客
11-04 485
#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*算法是一种在图中寻找最短路径的搜索算法，而二叉堆则是一种高效的优先队列数据结构，常用于优化路径查找过程。 ...
C++二叉堆实现.zip
08-20
在C++中，我们可以自定义二叉堆的数据结构并实现相关操作，如插入元素、删除最小/最大元素、调整堆等。 在给定的压缩包文件"C++二叉堆实现.zip"中，包含了两个文件：MyBinaryHeapTest.cpp 和 MyBinaryHeap.h。这...
二叉堆（最小堆）+二项堆+斐波那契堆
05-19
二叉堆、二项堆和斐波那契堆是数据结构中的重要概念，它们都是堆数据结构的不同变体，主要用于高效地实现某些特定操作，如查找最大或最小元素、优先队列以及各种排序算法。在C++编程语言中，理解和实现这些堆结构...
使用C++实现二叉堆
FS's Home
12-26 1622
二叉堆可以用来实现优先队列。二叉堆是一棵完全二叉树，除了叶子节点那一层，其他的层都是满的，叶子节点那一层是从左往右依次存放的，因此它们的父子元素的索引有数学公式可以参考，对于节点i来说，它的左儿子是2i，右儿子是2i+1，它的父亲节点是i/2向下取整，因此，在其内部我们可以通过数组来实现元素的存储，从而不需要链式结构，可以节约存储空间，提高访问速度（但是如果有合并操作，则会很慢，此时使用链式结构是
二叉堆的c++实现
weixin_42405632的博客
03-04 302
/************************************************************************ &amp;gt; File Name: BinaryHeap.cpp &amp;gt; Author: wpf &amp;gt; Mail: wpf9264@163.com &amp;gt; Created Time: 2019年03月04日 星期一...
c++数据结构——二叉堆
最新发布
緒山 まひろ
07-29 309
完全二叉树：所有层次都是满的，除了可能的最后一层，并且最后一层的节点尽可能地集中在左侧。堆序性：每个节点的键值必须满足最大堆或最小堆的堆序性条件。
二叉堆原理及实现(C++)
baidu_36161424的博客
05-28 1111
文章目录一、二叉堆简介二、二叉堆的实现2.1 基本定义2.2 堆的插入2.3 堆的删除 一、二叉堆简介 二叉堆是完全二元树或者是近似完全二元树，按照数据的排列方式可以分为两种：大根堆和小根堆。 大根堆：父节点键值总是大于等于任何一个子节点键值 小根堆：父节点键值总是小于等于任何一个子节点键值 性质： 索引为i的左孩子的索引是 (2*i+1); 索引为i的右孩子的索引是 (2*i+2); 索引为i...
用C++写二叉堆（优先队列）代码，详细注释
m0_56222998的博客
11-27 666
用C++自己编写二叉堆代码
二叉堆C++实现
qq_18431031的博客
08-03 282
堆是一棵被完全填满的二叉树，有可能的例外是在底层，底层上的元素从左到右填入。这样的树称为完全二叉树。完全二叉树的高度为logN下取整。在堆中，对于每一个节点X，X的parent中的关键字小于（或等于）X中的关键字，根节点除外。 ...
C++二叉堆实现
liufangping的博客
10-08 252
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 495
2019独角兽企业重金招聘Python工程师标准>>> ...
C/C++数据结构（八） —— 二叉堆
热门推荐
Edison's 小宇宙
10-10 1万+
⼆叉堆本质上是⼀种完全⼆叉树，它分为两个类型：最大堆 和 最小堆。
二叉堆(优先队列)与堆排序的完整实现(C++)
zorchp
12-12 678
-
数据结构之二叉堆及堆排序（C++）
碣石观海的博客
07-23 769
一、堆定义（Heap） n个元素的序列{k1,k2,...,kn}，当且仅当任意ki 满足以下关系时，称之为堆（也是完全二叉树）： 1.当k[i] <= k[2i] && k[i] <= k[2i+1] 时，称为小顶堆，即每个结点的值都小于等于其左右孩子结点的值； 2.当k[i] >= k[2i] && k[i] >= k[2i+1] ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值