概要

上一章介绍了堆和二叉堆的基本概念，并通过C语言实现了二叉堆。本章是二叉堆的C++实现。

目录
1. 二叉堆的介绍
2. 二叉堆的图文解析
3. 二叉堆的C++实现(完整源码)
4. 二叉堆的C++测试程序

转载请注明出处：http://www.cnblogs.com/skywang12345/p/3610382.html

更多内容：数据结构与算法系列 目录

(01) 二叉堆(一)之 图文解析 和 C语言的实现
(02) 二叉堆(二)之 C++的实现
(03) 二叉堆(三)之 Java的实

二叉堆的介绍

二叉堆是完全二元树或者是近似完全二元树，按照数据的排列方式可以分为两种：最大堆和最小堆。
最大堆：父结点的键值总是大于或等于任何一个子节点的键值；最小堆：父结点的键值总是小于或等于任何一个子节点的键值。示意图如下：

二叉堆一般都通过"数组"来实现。数组实现的二叉堆，父节点和子节点的位置存在一定的关系。有时候，我们将"二叉堆的第一个元素"放在数组索引0的位置，有时候放在1的位置。当然，它们的本质一样(都是二叉堆)，只是实现上稍微有一丁点区别。
假设"第一个元素"在数组中的索引为 0 的话，则父节点和子节点的位置关系如下：
(01) 索引为i的左孩子的索引是 (2*i+1);
(02) 索引为i的左孩子的索引是 (2*i+2);
(03) 索引为i的父结点的索引是 floor((i-1)/2);

假设"第一个元素"在数组中的索引为 1 的话，则父节点和子节点的位置关系如下：
(01) 索引为i的左孩子的索引是 (2*i);
(02) 索引为i的左孩子的索引是 (2*i+1);
(03) 索引为i的父结点的索引是 floor(i/2);

注意：本文二叉堆的实现统统都是采用"二叉堆第一个元素在数组索引为0"的方式！

二叉堆的图文解析

图文解析是以"最大堆"来进行介绍的。

1. 基本定义

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();

};

MaxHeap是最大堆的对应的类。它包括的核心内容是"添加"和"删除"，理解这两个算法，二叉堆也就基本掌握了。下面对它们进行介绍。

2. 添加

假设在最大堆[90,80,70,60,40,30,20,10,50]种添加85，需要执行的步骤如下：

如上图所示，当向最大堆中添加数据时：先将数据加入到最大堆的最后，然后尽可能把这个元素往上挪，直到挪不动为止！
将85添加到[90,80,70,60,40,30,20,10,50]中后，最大堆变成了[90,85,70,60,80,30,20,10,50,40]。

最大堆的插入代码(C++语言)

/*

 * 最大堆的向上调整算法(从start开始向上直到0，调整堆)

 *

 * 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。

 *

 * 参数说明：

 *     start -- 被上调节点的起始位置(一般为数组中最后一个元素的索引)

 */

template <class T>

void MaxHeap<T>::filterup(int start)

{

    int c = start;            // 当前节点(current)的位置

    int p = (c-)/;        // 父(parent)结点的位置

    T tmp = mHeap[c];        // 当前节点(current)的大小

    while(c > )

    {

        if(mHeap[p] >= tmp)

            break;

        else

        {

            mHeap[c] = mHeap[p];

            c = p;

            p = (p-)/;

        }

    }

    mHeap[c] = tmp;

}

/*

 * 将data插入到二叉堆中

 *

 * 返回值：

 *     0，表示成功

 *    -1，表示失败

 */

template <class T>

int MaxHeap<T>::insert(T data)

{

    // 如果"堆"已满，则返回

    if(mSize == mCapacity)

        return -;

    mHeap[mSize] = data;        // 将"数组"插在表尾

    filterup(mSize);    // 向上调整堆

    mSize++;                    // 堆的实际容量+1

    return ;

}

insert(data)的作用：将数据data添加到最大堆中。当堆已满的时候，添加失败；否则data添加到最大堆的末尾。然后通过上调算法重新调整数组，使之重新成为最大堆。

3. 删除

假设从最大堆[90,85,70,60,80,30,20,10,50,40]中删除90，需要执行的步骤如下：

如上图所示，当从最大堆中删除数据时：先删除该数据，然后用最大堆中最后一个的元素插入这个空位；接着，把这个“空位”尽量往上挪，直到剩余的数据变成一个最大堆。
从[90,85,70,60,80,30,20,10,50,40]删除90之后，最大堆变成了[85,80,70,60,40,30,20,10,50]。

注意：考虑从最大堆[90,85,70,60,80,30,20,10,50,40]中删除60，执行的步骤不能单纯的用它的字节点来替换；而必须考虑到"替换后的树仍然要是最大堆"！

最大堆的删除代码(C++语言)

/*

 * 最大堆的向下调整算法

 *

 * 注：数组实现的堆中，第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 = *c + ;     // 左(left)孩子的位置

    T tmp = mHeap[c];    // 当前(current)节点的大小

    while(l <= end)

    {

        // "l"是左孩子，"l+1"是右孩子

        if(l < end && mHeap[l] < mHeap[l+])

            l++;        // 左右两孩子中选择较大者，即mHeap[l+1]

        if(tmp >= mHeap[l])

            break;        //调整结束

        else

        {

            mHeap[c] = mHeap[l];

            c = l;

            l = *l + ;

        }

    }

    mHeap[c] = tmp;

}

/*

 * 删除最大堆中的data

 *

 * 返回值：

 *      0，成功

 *     -1，失败

 */

template <class T>

int MaxHeap<T>::remove(T data)

{

    int index;

    // 如果"堆"已空，则返回-1

    if(mSize == )

        return -;

    // 获取data在数组中的索引

    index = getIndex(data);

    if (index==-)

        return -;

    mHeap[index] = mHeap[--mSize];    // 用最后元素填补

    filterdown(index, mSize-);        // 从index位置开始自上向下调整为最大堆

    return ;

}

二叉堆的C++实现(完整源码)

二叉堆的实现同时包含了"最大堆"和"最小堆"。
二叉堆(最大堆)的实现文件(MaxHeap.cpp)

 /**

  * 二叉堆(最大堆)

  *

  * @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();

 }

 template <class T>

 MaxHeap<T>::MaxHeap(int capacity)

 {

     mSize = ;

     mCapacity = capacity;

     mHeap = new T[mCapacity];

 }

 /*

  * 析构函数

  */

 template <class T>

 MaxHeap<T>::~MaxHeap()

 {

     mSize = ;

     mCapacity = ;

     delete[] mHeap;

 }

 /*

  * 返回data在二叉堆中的索引

  *

  * 返回值：

  *     存在 -- 返回data在数组中的索引

  *     不存在 -- -1

  */

 template <class T>

 int MaxHeap<T>::getIndex(T data)

 {

     for(int i=; i<mSize; i++)

         if (data==mHeap[i])

             return i;

     return -;

 }

 /*

  * 最大堆的向下调整算法

  *

  * 注：数组实现的堆中，第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 = *c + ;     // 左(left)孩子的位置

     T tmp = mHeap[c];    // 当前(current)节点的大小

     while(l <= end)

     {

         // "l"是左孩子，"l+1"是右孩子

         if(l < end && mHeap[l] < mHeap[l+])

             l++;        // 左右两孩子中选择较大者，即mHeap[l+1]

         if(tmp >= mHeap[l])

             break;        //调整结束

         else

         {

             mHeap[c] = mHeap[l];

             c = l;

             l = *l + ;

         }

     }

     mHeap[c] = tmp;

 }

 /*

  * 删除最大堆中的data

  *

  * 返回值：

  *      0，成功

  *     -1，失败

  */

 template <class T>

 int MaxHeap<T>::remove(T data)

 {

     int index;

     // 如果"堆"已空，则返回-1

     if(mSize == )

         return -;

     // 获取data在数组中的索引

     index = getIndex(data);

     if (index==-)

         return -;

     mHeap[index] = mHeap[--mSize];    // 用最后元素填补

     filterdown(index, mSize-);        // 从index位置开始自上向下调整为最大堆

     return ;

 }

 /*

  * 最大堆的向上调整算法(从start开始向上直到0，调整堆)

  *

  * 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。

  *

  * 参数说明：

  *     start -- 被上调节点的起始位置(一般为数组中最后一个元素的索引)

  */

 template <class T>

 void MaxHeap<T>::filterup(int start)

 {

     int c = start;            // 当前节点(current)的位置

     int p = (c-)/;        // 父(parent)结点的位置

     T tmp = mHeap[c];        // 当前节点(current)的大小

     while(c > )

     {

         if(mHeap[p] >= tmp)

             break;

         else

         {

             mHeap[c] = mHeap[p];

             c = p;

             p = (p-)/;

         }

     }

     mHeap[c] = tmp;

 }

 /*

  * 将data插入到二叉堆中

  *

  * 返回值：

  *     0，表示成功

  *    -1，表示失败

  */

 template <class T>

 int MaxHeap<T>::insert(T data)

 {

     // 如果"堆"已满，则返回

     if(mSize == mCapacity)

         return -;

     mHeap[mSize] = data;        // 将"数组"插在表尾

     filterup(mSize);    // 向上调整堆

     mSize++;                    // 堆的实际容量+1

     return ;

 }

 /*

  * 打印二叉堆

  *

  * 返回值：

  *     0，表示成功

  *    -1，表示失败

  */

 template <class T>

 void MaxHeap<T>::print()

 {

     for (int i=; i<mSize; i++)

         cout << mHeap[i] << " ";

 }

 int main()

 {

     int a[] = {, , , , , , , , };

     int i, len=(sizeof(a)) / (sizeof(a[])) ;

     MaxHeap<int>* tree=new MaxHeap<int>();

     cout << "== 依次添加: ";

     for(i=; i<len; i++)

     {

         cout << a[i] <<" ";

         tree->insert(a[i]);

     }

     cout << "\n== 最 大 堆: ";

     tree->print();

     i=;

     tree->insert(i);

     cout << "\n== 添加元素: " << i;

     cout << "\n== 最 大 堆: ";

     tree->print();

     i=;

     tree->remove(i);

     cout << "\n== 删除元素: " << i;

     cout << "\n== 最 大 堆: ";

     tree->print();

     cout << endl; 

     return ;

 }

二叉堆(最小堆)的实现文件(MinHeap.cpp)

 /**

  * 二叉堆(最小堆)

  *

  * @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();

 }

 template <class T>

 MinHeap<T>::MinHeap(int capacity)

 {

     mSize = ;

     mCapacity = capacity;

     mHeap = new T[mCapacity];

 }

 /*

  * 析构函数

  */

 template <class T>

 MinHeap<T>::~MinHeap()

 {

     mSize = ;

     mCapacity = ;

     delete[] mHeap;

 }

 /*

  * 返回data在二叉堆中的索引

  *

  * 返回值：

  *     存在 -- 返回data在数组中的索引

  *     不存在 -- -1

  */

 template <class T>

 int MinHeap<T>::getIndex(T data)

 {

     for(int i=; i<mSize; i++)

         if (data==mHeap[i])

             return i;

     return -;

 }

 /*

  * 最小堆的向下调整算法

  *

  * 注：数组实现的堆中，第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 = *c + ;     // 左(left)孩子的位置

     T tmp = mHeap[c];    // 当前(current)节点的大小

     while(l <= end)

     {

         // "l"是左孩子，"l+1"是右孩子

         if(l < end && mHeap[l] > mHeap[l+])

             l++;        // 左右两孩子中选择较小者，即mHeap[l+1]

         if(tmp <= mHeap[l])

             break;        //调整结束

         else

         {

             mHeap[c] = mHeap[l];

             c = l;

             l = *l + ;

         }

     }

     mHeap[c] = tmp;

 }

 /*

  * 删除最小堆中的data

  *

  * 返回值：

  *      0，成功

  *     -1，失败

  */

 template <class T>

 int MinHeap<T>::remove(T data)

 {

     int index;

     // 如果"堆"已空，则返回-1

     if(mSize == )

         return -;

     // 获取data在数组中的索引

     index = getIndex(data);

     if (index==-)

         return -;

     mHeap[index] = mHeap[--mSize];        // 用最后元素填补

     filterdown(index, mSize-);    // 从index号位置开始自上向下调整为最小堆

     return ;

 }

 /*

  * 最小堆的向上调整算法(从start开始向上直到0，调整堆)

  *

  * 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。

  *

  * 参数说明：

  *     start -- 被上调节点的起始位置(一般为数组中最后一个元素的索引)

  */

 template <class T>

 void MinHeap<T>::filterup(int start)

 {

     int c = start;            // 当前节点(current)的位置

     int p = (c-)/;        // 父(parent)结点的位置

     T tmp = mHeap[c];        // 当前节点(current)的大小

     while(c > )

     {

         if(mHeap[p] <= tmp)

             break;

         else

         {

             mHeap[c] = mHeap[p];

             c = p;

             p = (p-)/;

         }

     }

     mHeap[c] = tmp;

 }

 /*

  * 将data插入到二叉堆中

  *

  * 返回值：

  *     0，表示成功

  *    -1，表示失败

  */

 template <class T>

 int MinHeap<T>::insert(T data)

 {

     // 如果"堆"已满，则返回

     if(mSize == mCapacity)

         return -;

     mHeap[mSize] = data;        // 将"数组"插在表尾

     filterup(mSize);            // 向上调整堆

     mSize++;                    // 堆的实际容量+1

     return ;

 }

 /*

  * 打印二叉堆

  *

  * 返回值：

  *     0，表示成功

  *    -1，表示失败

  */

 template <class T>

 void MinHeap<T>::print()

 {

     for (int i=; i<mSize; i++)

         cout << mHeap[i] << " ";

 }

 int main()

 {

     int a[] = {, , , , , , , , };

     int i, len=(sizeof(a)) / (sizeof(a[])) ;

     MinHeap<int>* tree=new MinHeap<int>();

     cout << "== 依次添加: ";

     for(i=; i<len; i++)

     {

         cout << a[i] <<" ";

         tree->insert(a[i]);

     }

     cout << "\n== 最 小 堆: ";

     tree->print();

     i=;

     tree->insert(i);

     cout << "\n== 添加元素: " << i;

     cout << "\n== 最 小 堆: ";

     tree->print();

     i=;

     tree->remove(i);

     cout << "\n== 删除元素: " << i;

     cout << "\n== 最 小 堆: ";

     tree->print();

     cout << endl; 

     return ;

 }

二叉堆的C++测试程序

测试程序已经包含在相应的实现文件(MaxHeap.cpp)中了，下面只列出程序运行结果。

最大堆(MaxHeap.cpp)的运行结果：

== 依次添加:

== 最 大 堆:

== 添加元素:

== 最 大 堆:

== 删除元素:

== 最 大 堆:

最小堆(MinHeap.cpp)的运行结果：

== 依次添加:

== 最 小 堆:

== 添加元素:

== 最 小 堆:

== 删除元素:

== 最 小 堆:

PS. 二叉堆是"堆排序"的理论基石。以后讲解算法时会讲解到"堆排序"，理解了"二叉堆"之后，"堆排序"就很简单了。

二叉堆(二)之 C++的实现的更多相关文章

  1. 笔试算法题（46）：简介 - 二叉堆 & 二项树 & 二项堆 & 斐波那契堆

    二叉堆(Binary Heap) 二叉堆是完全二叉树(或者近似完全二叉树):其满足堆的特性:父节点的值>=(<=)任何一个子节点的键值,并且每个左子树或者右子树都是一 个二叉堆(最小堆或者 ...

  2. 二叉堆(一)之 图文解析 和 C语言的实现

    概要 本章介绍二叉堆,二叉堆就是通常我们所说的数据结构中"堆"中的一种.和以往一样,本文会先对二叉堆的理论知识进行简单介绍,然后给出C语言的实现.后续再分别给出C++和Java版本 ...

  3. 二叉堆(三)之 Java的实现

    概要 前面分别通过C和C++实现了二叉堆,本章给出二叉堆的Java版本.还是那句话,它们的原理一样,择其一了解即可. 目录1. 二叉堆的介绍2. 二叉堆的图文解析3. 二叉堆的Java实现(完整源码) ...

  4. 在A*寻路中使用二叉堆

    接上篇:A*寻路初探 GameDev.net 在A*寻路中使用二叉堆 作者:Patrick Lester(2003年4月11日更新) 译者:Panic 2005年3月28日 译者序 这一篇文章,是&q ...

  5. PHP利用二叉堆实现TopK-算法的方法详解

    前言 在以往工作或者面试的时候常会碰到一个问题,如何实现海量TopN,就是在一个非常大的结果集里面快速找到最大的前10或前100个数,同时要保证 内存和速度的效率,我们可能第一个想法就是利用排序,然后 ...

  6. 【算法与数据结构】二叉堆和优先队列 Priority Queue

    优先队列的特点 普通队列遵守先进先出(FIFO)的规则,而优先队列虽然也叫队列,规则有所不同: 最大优先队列:优先级最高的元素先出队 最小优先队列:优先级最低的元素先出队 优先队列可以用下面几种数据结 ...

  7. PHP-利用二叉堆实现TopK-算法

    介绍 在以往工作或者面试的时候常会碰到一个问题,如何实现海量TopN,就是在一个非常大的结果集里面快速找到最大的前10或前100个数,同时要保证内存和速度的效率,我们可能第一个想法就是利用排序,然后截 ...

  8. Python实现二叉堆

    Python实现二叉堆 二叉堆是一种特殊的堆,二叉堆是完全二元树(二叉树)或者是近似完全二元树(二叉树).二叉堆有两种:最大堆和最小堆.最大堆:父结点的键值总是大于或等于任何一个子节点的键值:最小堆: ...

  9. AC日记——二叉堆练习3 codevs 3110

    3110 二叉堆练习3  时间限制: 3 s  空间限制: 128000 KB  题目等级 : 黄金 Gold 题解       题目描述 Description 给定N(N≤500,000)和N个整 ...

随机推荐

  1. Windows下如何枚举所有进程

    要编写一个类似于 Windows 任务管理器的软件,首先遇到的问题是如何实现枚举所有进程.暂且不考虑进入核心态去查隐藏进程一类的,下面提供几种方法.请注意每种方法的使用局限,比如使用这些 API 所需 ...

  2. android: SQLite查询数据

    掌握了查询数据的方法之后,你也就将数据库的 CRUD 操 作全部学完了.不过千万不要因此而放松,因为查询数据也是在 CRUD 中最复杂的一种 操作. 我们都知道 SQL 的全称是 Structured ...

  3. Revit中如何将视图过滤器传递到其它项目

    在Revit中采用过滤器控制视图显示,利用过滤器给图元着色,利用过滤器控制视图显示或隐藏等,那么,在不同的项目中是否每次都要设置相同的过滤器,其实,Revit提供了这么一种在不同项目传递信息的方式,在 ...

  4. NFS性能优化

    参考: http://www.techrepublic.com/blog/linux-and-open-source/tuning-nfs-for-better-performance/ 1.服务器端 ...

  5. Scala 深入浅出实战经典 第61讲：Scala中隐式参数与隐式转换的联合使用实战详解及其在Spark中的应用源码解析

    王家林亲授<DT大数据梦工厂>大数据实战视频 Scala 深入浅出实战经典(1-87讲)完整视频.PPT.代码下载: 百度云盘:http://pan.baidu.com/s/1c0noOt ...

  6. webpack处理Img标签路径的几种情况

    在使用webpack过程中遇到这个问题,各种搜索遇到此问题的还真不少,但都没有一个完整的说明. 后来研究下,图片除了路径替换还是就是图片做优化主是小于一定大小的通过转 base64 inline方式减 ...

  7. ASP.NET MVC 分部视图

    @model PartViewDemo.Models.HomeInfo@using PartViewDemo.Models;@{ ViewBag.Title = "Index";} ...

  8. PyCharm 134 单元测试输出大量空行解决方案

    在某次BugFix中,某哥们儿在/helper/pycharm/tcunittest.py加了个这: 各位亲们可以把True改为False即可解决大量空行的问题.

  9. [emacs org-mode小技巧] org-indent-mode 让文档更容易阅读

    刚发现Emacs的org-mode里面一个叫做 org-indent-mode 的minor mode对于阅读org-mode文档很不错,版面看起来清晰多了: 从上图可以看到,org-indent-m ...

  10. 桌面oracle 11g导入多年库的dump备忘

    接到客户6G的dump文件.先导入桌面orcale ,imp提示出错,执行impdp后如下 连接到: Oracle Database 11g Express Edition Release 11.2. ...