最小堆c++实现

最新推荐文章于 2022-05-18 14:02:41 发布
最新推荐文章于 2022-05-18 14:02:41 发布
阅读量888 收藏 6
点赞数 2
分类专栏： 经典算法 文章标签： 最小堆
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43850253/article/details/114443398
版权

前言

恰逢春招面试时, 大厂们都会考察对基本数据结构的掌握情况。这里有一个重点就是利用数组实现堆。据说有些面试官会要求白板手写堆。虽然我们在编码过程中可以借助STL的优先队列 priority_queue 来实现堆，但是掌握其原理还是很重要滴。



堆的实现

是时候搬出当年写数据结构的代码了。这里给了一4个最小堆的例子，而最大堆的实现与此例子差不多，故此处就不赘述了。
这里的关键是 siftDown 和 siftUp 函数。

最小堆的定义

//
// Created by Dell on 2019/12/15.
//

#include <iomanip>
#include <iostream>
#include <queue>
using namespace std;
const int DefaultSize = 30;


template<class T>
class MinHeap {
public:
    MinHeap(int sz = DefaultSize);
    MinHeap(T arr[], int n);
    ~MinHeap() { delete[] heap; }
    bool Insert(const T& x);
    bool RemoveMin(T& x);
    bool IsEmpty() const;
    bool IsFull() const;
    void makeEmpty() { currentSize = 0; }
    int GetTreeDepth(int v);
    void PrintHeap();


private:
    T* heap;
    int currentSize;
    int maxHeapSize;
    void siftDown(int start, int m);
    void siftUp(int start);
};



两种构造函数

template<class T>
MinHeap<T>::MinHeap(int sz)
{
    maxHeapSize = (DefaultSize > sz) ? DefaultSize : sz;
    heap = new T[maxHeapSize];
    if (heap == 0)
    {
        cerr << "堆存储分配失败" << endl;
        exit(1);
    }
    currentSize = 0;
}


template<class T>
MinHeap<T>::MinHeap(T arr[], int n)
{
    maxHeapSize = (DefaultSize > n) ? DefaultSize : n;
    heap = new T[maxHeapSize];
    if (heap == 0)
    {
        cerr << "堆存储分配错误" << endl;
        exit(1);
    }
    for (int i = 0; i < n; i++)
        heap[i] = arr[i];
    currentSize = n;
    int currentPos = (currentSize - 2) / 2;
    while (currentPos >= 0) {
        siftDown(currentPos, currentSize - 1);
        currentPos--;
    }
}



最小堆的添加一个元素

template<class T>
bool MinHeap<T>::Insert(const T& x)
{
    if (currentSize == maxHeapSize)
    {
        cerr << "Heap Full" << endl;
        return false;
    }
    heap[currentSize] = x;
    siftUp(currentSize);
    currentSize++;
    return true;
}

其中siftUp函数的实现:

template<class T>
void MinHeap<T>::siftUp(int start)
{
    int j = start, i = (j - 1) / 2;
    T temp = heap[j];
    while (j > 0)
    {
        if (heap[i] <= temp)
            break;
        else
        {
            heap[j] = heap[i];
            j = i;
            i = (i - 1) / 2;
        }
    }
    heap[j] = temp;
}



最小堆删除一个元素

template<class T>
bool MinHeap<T>::RemoveMin(T& x)
{
    if (!currentSize)
    {
        cout << "Heap empty" << endl;
        return false;
    }
    x = heap[0];
    heap[0] = heap[currentSize - 1];
    currentSize--;
    siftDown(0, currentSize - 1);
    return true;
}

其中siftDown的实现:

template<class T>
void MinHeap<T>::siftDown(int start, int m)
{
    int i = start, j = 2 * i + 1;
    T temp = heap[i];
    while (j <= m)
    {
        if (j < m && heap[j] > heap[j + 1])
            j++;
        if (temp < heap[j])
            break;
        else
        {
            heap[i] = heap[j];
            i = j;
            j = 2 * j + 1;
        }
    }
    heap[i] = temp;
}



其他一些函数

template<class T>
bool MinHeap<T>::IsEmpty() const
{
    return currentSize == 0;
}


template<class T>
bool MinHeap<T>::IsFull() const
{
    return currentSize == maxHeapSize;
}


template<class T>
int MinHeap<T>::GetTreeDepth(int v)
{
    int depth = 0;
    while (v < currentSize)
    {
        v = 2 * v + 1;
        depth++;
    }
    return depth;
}


template<class T>
void MinHeap<T>::PrintHeap()
{
    int IsEven= 1;
    queue<int> Q;
    int v;
    Q.push(0);
    while (!Q.empty())
    {
        IsEven = 1;
        int width = Q.size();
        for (int i = 0; i < width; i++)
        {
            v = Q.front();
            Q.pop();
            IsEven = (IsEven+1) % 2;
            cout << setw(4) << heap[v];
            if (IsEven && i != width - 1)
                cout << " , ";
            if (2 * v + 1 < currentSize)
                Q.push(2 * v + 1);
            if (2 * v + 2 < currentSize)
                Q.push(2 * v + 2);
        }
        cout << endl;
    }
    cout << endl << endl << endl;
}

完整代码

//
// Created by Dell on 2019/12/15.
//

#include <iomanip>
#include <iostream>
#include <queue>
using namespace std;
const int DefaultSize = 30;


template<class T>
class MinHeap {
public:
    MinHeap(int sz = DefaultSize);
    MinHeap(T arr[], int n);
    ~MinHeap() { delete[] heap; }
    bool Insert(const T& x);
    bool RemoveMin(T& x);
    bool IsEmpty() const;
    bool IsFull() const;
    void makeEmpty() { currentSize = 0; }
    int GetTreeDepth(int v);
    void PrintHeap();


private:
    T* heap;
    int currentSize;
    int maxHeapSize;
    void siftDown(int start, int m);
    void siftUp(int start);
};


template<class T>
MinHeap<T>::MinHeap(int sz)
{
    maxHeapSize = (DefaultSize > sz) ? DefaultSize : sz;
    heap = new T[maxHeapSize];
    if (heap == 0)
    {
        cerr << "堆存储分配失败" << endl;
        exit(1);
    }
    currentSize = 0;
}


template<class T>
MinHeap<T>::MinHeap(T arr[], int n)
{
    maxHeapSize = (DefaultSize > n) ? DefaultSize : n;
    heap = new T[maxHeapSize];
    if (heap == 0)
    {
        cerr << "堆存储分配错误" << endl;
        exit(1);
    }
    for (int i = 0; i < n; i++)
        heap[i] = arr[i];
    currentSize = n;
    int currentPos = (currentSize - 2) / 2;
    while (currentPos >= 0) {
        siftDown(currentPos, currentSize - 1);
        currentPos--;
    }
}


template<class T>
void MinHeap<T>::siftDown(int start, int m)
{
    int i = start, j = 2 * i + 1;
    T temp = heap[i];
    while (j <= m)
    {
        if (j < m && heap[j] > heap[j + 1])
            j++;
        if (temp < heap[j])
            break;
        else
        {
            heap[i] = heap[j];
            i = j;
            j = 2 * j + 1;
        }
    }
    heap[i] = temp;
}


template<class T>
void MinHeap<T>::siftUp(int start)
{
    int j = start, i = (j - 1) / 2;
    T temp = heap[j];
    while (j > 0)
    {
        if (heap[i] <= temp)
            break;
        else
        {
            heap[j] = heap[i];
            j = i;
            i = (i - 1) / 2;
        }
    }
    heap[j] = temp;
}


template<class T>
bool MinHeap<T>::Insert(const T& x)
{
    if (currentSize == maxHeapSize)
    {
        cerr << "Heap Full" << endl;
        return false;
    }
    heap[currentSize] = x;
    siftUp(currentSize);
    currentSize++;
    return true;
}




template<class T>
bool MinHeap<T>::RemoveMin(T& x)
{
    if (!currentSize)
    {
        cout << "Heap empty" << endl;
        return false;
    }
    x = heap[0];
    heap[0] = heap[currentSize - 1];
    currentSize--;
    siftDown(0, currentSize - 1);
    return true;
}





template<class T>
bool MinHeap<T>::IsEmpty() const
{
    return currentSize == 0;
}







template<class T>
bool MinHeap<T>::IsFull() const
{
    return currentSize == maxHeapSize;
}





template<class T>
int MinHeap<T>::GetTreeDepth(int v)
{
    int depth = 0;
    while (v < currentSize)
    {
        v = 2 * v + 1;
        depth++;
    }
    return depth;
}

template<class T>
void MinHeap<T>::PrintHeap()
{
    int IsEven= 1;
    queue<int> Q;
    int v;
    Q.push(0);
    while (!Q.empty())
    {
        IsEven = 1;
        int width = Q.size();
        for (int i = 0; i < width; i++)
        {
            v = Q.front();
            Q.pop();
            IsEven = (IsEven+1) % 2;
            cout << setw(4) << heap[v];
            if (IsEven && i != width - 1)
                cout << " , ";
            if (2 * v + 1 < currentSize)
                Q.push(2 * v + 1);
            if (2 * v + 2 < currentSize)
                Q.push(2 * v + 2);
        }
        cout << endl;
    }
    cout << endl << endl << endl;
}



int main()
{
    MinHeap<int> a;

    a.Insert(53);
    //a.PrintHeap();
    a.Insert(65);
    //a.PrintHeap();
    a.Insert(27);
    //a.PrintHeap();
    a.Insert(56);
    //a.PrintHeap();
    a.Insert(39);
    //a.PrintHeap();
    a.Insert(58);
    //a.PrintHeap();
    a.Insert(100);
    //a.PrintHeap();
    a.Insert(18);
    a.PrintHeap();
    a.Insert(569);
    a.Insert(47);
    a.Insert(93);
    a.Insert(24);
    a.Insert(66);
    a.Insert(78);
    a.Insert(134);
    a.PrintHeap();


    cout << endl;
}
Andy Dennis
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C/C++ 最小堆min_heap算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-30 138
【代码】C/C++ 最小堆min_heap算法详解及源码。
c++ 最小堆实现
11-27
c++ 最小堆 还不错 标准库没有 自己做作业用。
最小堆C++实现
My_Algorithm的博客
07-03 3483
最小堆是指在树中，存在一个结点而且该结点有儿子结点，该结点的data域值都小于其儿子结点的data域值，并且它是一个完全二叉树（不是满二叉树）。 这里使用静态数组存储完全二叉树，对于完全二叉树采用顺序存储表示，那么对于任意一个下标为i(1 ≤ i ≤ n)的结点： 父结点为：i / 2（i ≠ 1），若i = 1，则i是根节点。 左子结点：2i（2i ≤ n）， 若不满足则无左子结点。 右子结点：2i + 1(2i + 1 ≤ n)，若不满足则无右子结点。 最小堆的定义： class Mi.
C++ 最小堆
ChanJose的博客
03-14 1668
// 对最小堆的各种操作 // 最小堆：完全二叉树，可以采用顺序存储结构 #include &lt;iostream&gt; #include &lt;stack&gt; const int DefaultSize = 100; template &lt;class T&gt; class MinHeap{ public: MinHeap(int sz = DefaultSiz...
堆——最小堆代码实现与分析(C++)
Tokameine的博客
02-14 787
最近跟着黑皮书学习数据结构，主要代码均与书上相仿。代码量有些大，所以全代码之后丢在结尾。先摘抄部分来进行分析吧。 优先队列（堆）： 一种能够赋予每个节点不同优先级的数据结构。有“最小堆”和“最大堆”两种基础类型。实现的根本原理有两种，一种是“数组”，另外一种则是“树”(大多是指二叉树)。但在实现最大/最小堆时，使用数组更优。因为堆并不像树那样需要很多功能支持，自然也不需要用到指针(当然，高级结构还是会用到的，比如“左式堆”等)。 如果您此前已经看过堆的基本结构概念，那应该大致明白...
C++最小堆
qq_33795447的博客
04-19 854
#include <iostream> class MinHeap { private: int _max; int _count; int *_ptr; public: explicit MinHeap(int number) { _max = number; _count = 0; _ptr = new int(_max); } ~MinHeap() { if.
BiTreeApp.rar_c++测试数据_最小堆_最小堆 C
最新发布
09-22
5. **C++实现**： 在C++中实现这些数据结构时，可以使用类或结构体来封装节点，包含数据成员和指针成员，然后提供插入、删除、查找等操作的成员函数。同时，为了实现最小堆，可以维护一个动态数组，使用索引来模拟...
代码c++ 最大堆最小堆
01-03
虽然`std::set`不是一个标准的堆实现，但在本例中，由于`set`会自动按升序排列元素（相当于最小堆），我们可以利用它来模拟最小堆的行为。对于最大堆，代码通过从`set`的末尾获取最大值来模拟其行为。`set`的迭代器`...
解读堆排序算法及用C++实现基于最大堆的堆排序示例
12-25
1、堆排序定义 ...【例】关键字序列(10，15，56，25，30，70)和(70，56，30，25，15，10)分别满足堆性质(1)和(2)，故它们均是堆，其对应的完全二叉树分别如最小堆示例和最大堆示例所示。 堆排序算法 2、
C++实现优先队列——最小堆，d路堆及配对堆
酒
04-25 2636
C++实现三种优先队列
最小堆的C++实现
iqRocket的专栏
11-08 7696
最小堆，即树根的值是最小的，也是一棵完全二叉树。它以层次结构来区分值的大小。并且最小堆可以帮助我们高效地取出具有最小值。它也是实现优先级队列的高效结构。 #include using namespace std; int heap[100]; //下滑操作 void siftDown(int start,int end) { //将start号结点向下调整直到end int i=s
C++最小堆实现
Muzzik的博客
05-24 443
mini_heap.h #pragma once #include <cstdint> template <class T> class mini_heap { private: struct node { uint32_t size; T* data; }; node* _heap; //最小堆 uint32_t _max_size; //最大存储数 uint32_t _size; //存储数 // 扩容 void expansion();
数据结构最小堆C++实现
Brillian123的博客
05-18 3622
#pragma once # include<iostream> using namespace std; int DefaultSize = 10; //定义最小堆默认存储数据的数目 //最小堆的头文件，包括类定义及接口的实现。 template <class T> class MinHeap { public: MinHeap(int sz = DefaultSize); //构造函数，建立空堆 ......
C++构建最小堆
idelamadaqt的博客
03-01 817
将数组按自下向上扫描，向下调整的方法，调整为最小堆
C++ 最小堆实现
榕易的易
03-19 884
最小堆特征 最小堆是一棵完全二叉树，通常使用数组来实现： 树的根为Arr[0] 对于其他 i 节点，则有其他公式： 公式 返回值 Arr[(i-1)/2] 返回 i 节点的父节点 Arr[(2*i)+1] 返回 i 节点的左孩子 Arr[(2*i)+2] 返回 i 节点的右孩子 最小堆类定义 先看最小堆的class 定义声明，我们使用数组实现最小堆 class MinHeap { private: int *harr; // pointer to array of e
数据结构（C++） —— 最小堆（mainHeap）
Anna的博客
02-19 1913
一、理论知识普及： 假定在各个数据记录（元素）中存在一个能够标识数据记录（元素）的数据项，并将依据该数据项对数据进行组织，这个数据项就成为关键码（KEY）。 如果有一个关键码的集合，把它的所有元素按完全二叉树的顺序存储方式存放在一个一维数组中，并满足无论在哪棵树上看，父节点的值总比子节点的小，称这个集合为最小堆。 二、性质： 由于对存储在下标从0开始计数的数组中，因此，在堆中给定下标为i的
最小堆&&最大堆的实现(c++)
熊晓杰 -- (暴熊 || kongbu0621 || kongbu0622) 的专栏
10-06 4391
最小堆:templateclass MinHeap {public: MinHeap(int MinHeapSize = 10); ~MinHeap() {delete [] heap;} int Size() const {return CurrentSize;} T Min() {if (CurrentSize == 0) throw OutOfBoun
C++实现最小堆与树与森林基础
在C++编程中，"堆的建立"这一概念主要与数据结构中的优先队列相关，特别是最小堆（MinHeap）的实现。最小堆是一种特殊的完全二叉树，其中每个节点的值都小于或等于其子节点的值，通常用于求解最优化问题。在`MinHeap...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值