（堆的应用）Huffman赫夫曼树的建立

建立Huffman树的基本思路：给定有权重的一系列数据（带权重），从中挑选最小权重的两个数据，组成一棵树，得到的父节点再插入到数据系列当中。

开始的时候按着严老师的办法，是借助顺序表来完成Huffman树的建立；同样，在建树过程中要从顺序表中选择比较小的两个数，相加后再插入到表尾，如此往复，知道所有给出的点都插入为止。

通过最小堆来建树也很灵活便捷。堆的性能高，排序时间复杂度为nlog(2)n，利用最小堆，就可以将很快找出最小的元素（总是在顶部）。

下面8步立刻掌握利用最小堆来建立Huffman树。

看图解说

①原图（已经是最小堆）；

②交换堆的首元素（肯定是最小的）和最后一个元素对换；

③交换后删除最后一个元素（复制出来），其实也不是真正的删除，只是size-1这个操作而已；调换后就不是堆了，重新调整heap为最小堆，调整可以用递归调用，也可以用下标作为判断条件，我的代码用的是下标判断条件；

④继续②；

⑤弹出最小的，调整；将两个最小点复制出来后，组成新的父节点，调整他们之间的内部指针关系；

⑥调整后；

⑦插入新节点，调整；

⑧调整后。

以上做了第一遍的操作，继续做下去知道堆中只剩下最后一个元素为止，再将root指向其就可以了，下面是代码。如此下来，Huffman树就建好了。

Huffman节点数据结构设计：

?

#ifndef _HUFFMANNODE_H_

#define _HUFFMANNODE_H_

 

struct HuffmanNode              //Huffman节点定义

{

private:

    int data;

 

public:

    //构造函数

    HuffmanNode * left,* right,* parent;

    HuffmanNode():left(NULL),right(NULL),parent(NULL),data(-1){}

    HuffmanNode(int d):left(NULL),right(NULL),parent(NULL),data(d){}

 

    //重载运算符

    HuffmanNode &operator=(const HuffmanNode& hn)

    {

        left = hn.left;

        right = hn.right;

        data = hn.data;

        return *this;

    }

 

    //数据的获取和维护

    int GetData()const{return data;}                        //获取数据

    bool SetData(int d){data = d;return true;}      //设置数据

};

 

#endif

 最小堆类：

?

#include <iostream>

using namespace std;

 

#ifndef _MINHEAP_H_

#define _MINHEAP_H_

 

#include "HuffmanNode.h"

 

const int DefaultSize = 100;

 

class MinHeap

{

    HuffmanNode * heap;

    int szCurrent;

 

public:

    MinHeap(int sz = DefaultSize);

    ~MinHeap()

    {delete [] heap;}

 

    void CreateMinHeap(int arr[],int n);        //数组构建最小堆

    bool Insert(HuffmanNode * e);               //往堆中插入Huffman节点

    void SiftDown(int start,int m);             //下滑，重建最小堆

    void SiftUp(int start,int m);                   //上滑，在插入的时候用到

    HuffmanNode * GetMinNode();             //获取Huffman节点data值最小的节点，同时维护szCurrent

    bool SwapNode(int i,int j);                     //交换下标为i和j的Huffman节点

    void Print();                                           //打印Huffman节点

};

 

#endif

 

#include <iostream>

using namespace std;

#include "MinHeap.h"

#include <assert.h>

 

MinHeap::MinHeap(int sz)

{

    heap = new HuffmanNode[sz];

    assert(heap!=NULL);

    szCurrent = 0;

}

 

void MinHeap::CreateMinHeap(int arr[],int n)

{

    this->heap = new HuffmanNode[DefaultSize];

    assert(heap!=NULL);

 

    int i;

    for(i=0; i<n; i++)

        heap[i].SetData(arr[i]);

 

    szCurrent = n;

 

    int currentpos = (szCurrent-2)/2;           //从最后一个顶点开始调整

    while(currentpos >= 0)

    {

        SiftDown(currentpos,szCurrent-1);

        currentpos -- ;

    }

}

 

void MinHeap::SiftDown(int start,int m)

{

    int i = start,j = i*2+1;

    HuffmanNode temp = heap[i];

    while(j<=m) 

    {

        if(j<m && heap[j].GetData() > heap[j+1].GetData())            //j记录比较小的子节点

            j++;

 

        if(temp.GetData() <= heap[j].GetData())          //不调整

            break;

        else

        {

            heap[i] = heap[j];          //子节点上移

            i = j;

            j = 2*j+1;

        }

    }

    heap[i] = temp;

}

 

void MinHeap::SiftUp(int start,int m)

{

    int j = start,              //子节点位置

        i = (start-1) / 2;  //顶点位置

    HuffmanNode temp = heap[j]; //记录子节点

    while(j > 0)

    {

        if(temp.GetData() > heap[i].GetData())           //不调整

            break;

        else

        {

            heap[j] = heap[i];          //顶点下滑

            j = i;

            i = (i-1) / 2;

        }

    }

    heap[j] = temp;

}

 

void MinHeap::Print()

{

    for(int i=0; i<szCurrent; i++)

        cout << heap[i].GetData() << " ";

    cout << endl;

}

 

bool MinHeap::Insert(HuffmanNode * e)

{

    szCurrent++;

    if(szCurrent > DefaultSize)

        abort();

     

    heap[szCurrent-1] = *e;

    SiftUp(szCurrent-1,0);          //调整

    return true;

}

 

HuffmanNode * MinHeap::GetMinNode()

{

    if(szCurrent>0)

    {

        HuffmanNode * t;

        SwapNode(0,szCurrent-1);        //此时heap[0].data是最小的，让它跟最后一个元素调换

        szCurrent--;

        SiftDown(0,szCurrent-1);

        t = new HuffmanNode();

        * t = heap[szCurrent];

        cout << "GetMinNode()后得到的堆：";

        Print();

        return t;

    }

    return NULL;

}

 

bool MinHeap::SwapNode(int i,int j)

{

    swap(heap[i],heap[j]);

    return true;

}

Huffman类：

?

#include "MinHeap.h"

 

#ifndef _HUFFMANTREE_H_

#define _HUFFMANTREE_H_

 

class Huffman

{

    MinHeap * mh;                   //堆，协助建立Huffman树

    HuffmanNode * root;         //Huffman树的根节点

 

public:

    Huffman():root(NULL){};

    ~Huffman()

    {

        delete mh;

        MakeEmpty(root);

    }

    void MakeEmpty(HuffmanNode * ptr)

    {

        if(ptr->left)

            MakeEmpty(ptr->left);

        if(ptr->right)

            MakeEmpty(ptr->right);

        delete ptr;

    }

     void CreateHuffmanTree(int arr[],int size);

     void Print();

};

 

#endif

 

 

#include <iostream>

using namespace std;

#include <assert.h>

#include "HuffmanTree.h"

#include "MinHeap.h"

#include <queue>

 

void Huffman::CreateHuffmanTree(int arr[],int size)

{

    mh = new MinHeap(size);

    mh->CreateMinHeap(arr,size);         //将数据建立最小堆

    int i;

    HuffmanNode * left;

    HuffmanNode * right;

    HuffmanNode * parent;

 

    for(i=0; i<size-1; i++)

    {

        left = mh->GetMinNode();         //较小成为左孩子

        right = mh->GetMinNode();            //较大成为右孩子

         

        //这里可以归结出一个函数来，但是有点麻烦，直观点

        parent = new HuffmanNode(left->GetData()+right->GetData());

        parent->left = left;

        parent->right = right;

        left->parent = right->parent = parent;

 

        if(!mh->Insert(parent))

            abort();

 

        cout<< "插入父节点之后的堆：";

        mh->Print();

    }

    root = parent;

}

 

void Huffman::Print()

{

    queue<HuffmanNode *> q;

    q.push(root);

    HuffmanNode * p;

    while(!q.empty())

    {

        p = q.front();

        cout << p->GetData() << " ";

        if(p->left != NULL)

            q.push(p->left);

        if(p->right != NULL)

            q.push(p->right);

        q.pop();

    }

}

Huffman（哈弗曼，赫夫曼）在通信领域用途很大，在文件压缩技术也有所运用，做些笔记，以后有用，与大家共享，欢迎讨论:)。

当前标签: 别说我学过C++

 

C++对析构函数的误解 捣乱小子 2011-12-09 11:56 阅读:18 评论:0  

 

C++虚函数和纯虚函数（2） 捣乱小子 2011-12-04 16:16 阅读:62 评论:0  

 

C++虚函数和纯虚函数（1） 捣乱小子 2011-12-04 13:16 阅读:1062 评论:3  

 

C++静态数据成员和静态成员函数 捣乱小子 2011-12-03 13:35 阅读:16 评论:0  

 

sizeof运算符和strlen函数的区别 捣乱小子 2011-11-10 22:53 阅读:15 评论:0