哈弗曼实现（C++）

HuffmanCode.h

 #ifndef HUFFMANCODE_H
 #define HUFFMANCODE_H

 enum LRSTATUS
 {
     LEFTCHILD, //左子树
     RIGHTCHILD //右子树
 };

 struct HuffmanCode
 {
     //哈弗曼编码类
     int weight; //权值
     int * pPath; //路径指针
     int pathLength; //路径长度
     HuffmanCode() //默认构造函数
     {
         weight = ;
         pPath = ;
         pathLength = ;
     }
     //HuffmanCode(int n) //初始化路径指针成员
     //{
     //    pPath = new int [n];
     //}
     //~HuffmanCode() //销毁并释放路径指针成员
     //{
     //    if (0!=pPath)
     //    {
     //        delete [] pPath;
     //        pPath = 0;
     //    }
     //}
 };

 #endif //HUFFMANCODE_H

HuffmanNode.h

 #ifndef HUFFMANNODE_H
 #define HUFFMANNODE_H

 enum NODESTATUS
 {
     IN_FOREST, //在森林中
     OUT_FOREST //不在森林中
 };

 struct HuffmanNode
 {
     //哈弗曼节点结构类
     int weight; //节点权值
     NODESTATUS flag; //是否在森林里的标志：IN_FOREST为在森林中；OUT_FOREST为不在森林中
     HuffmanNode * parent; //双亲指针
     HuffmanNode * lChild; //左子树指针
     HuffmanNode * rChild; //右子树指针

     HuffmanNode() //初始化成员数据
     {
         weight = ;
         flag = OUT_FOREST;
         parent = ;
         lChild = ;
         rChild = ;
     }
 };

 #endif //HUFFMANNODE_H

HuffmanTree.h

 #ifndef HUFFMANTREE_H
 #define HUFFMANTREE_H

 #include "HuffmanCode.h"
 #include "HuffmanNode.h"

 class HuffmanTree
 {
     //哈夫曼树类
 private:
     HuffmanNode * pNode; //哈弗曼节点指针（即哈弗曼树的节点数组）
     HuffmanCode * pCode; //哈弗曼编码指针（即哈弗曼树的路径数组）
     int * pWeight; //哈弗曼权值指针（即哈弗曼树的权值数组）
     int size; //哈弗曼权值数组大小
 protected:
 public:
     HuffmanTree(int * pWeight, int size); //哈夫曼树构造函数
     ~HuffmanTree(){}; //哈弗曼树析构函数

     void CreateHuffmanTree(HuffmanNode ** ppNode); //创建哈弗曼树，使用ppNode返回哈弗曼节点数组
     void GetHuffmanCode(HuffmanNode * pNode, HuffmanCode ** ppCode); //获取哈弗曼编码，使用ppCode返回哈弗曼路径数组
 };

  void FreeHuffmanTree(HuffmanNode ** ppNode); //释放有函数CreateHuffmanTree申请的动态内存
  void FreeHuffmanTree(HuffmanCode ** ppCode); //释放有函数GetHuffmanCode申请的动态内存

 #endif //HUFFMANTREE_H

HuffmanTree.cpp

 #include "HuffmanTree.h"
 #include <iostream>
 #include <iomanip> //for setw()

 using namespace std;

 #define DEBUG

 #define MAX_VALUE 0x7FFFFFFF
 #define WIDTH 12

 //************************************
 // Method:    HuffmanTree
 // FullName:  HuffmanTree::HuffmanTree
 // Access:    public
 // Returns:
 // Qualifier: HuffmanTree类构造函数，使用HuffmanTree类之前必须进行类对象初始化
 // Parameter: int * pWeight
 // Parameter: int size
 //************************************
 HuffmanTree::HuffmanTree(int * pWeight, int size)
 {
     this->pWeight = pWeight;
     this->size = size;
 }

 //************************************
 // Method:    CreateHuffmanTree
 // FullName:  HuffmanTree::CreateHuffmanTree
 // Access:    public
 // Returns:   void
 // Qualifier: 创建哈弗曼树，返回指向保存哈弗曼树节点数组的指针
 // Parameter: HuffmanNode * * ppNode
 //************************************
 void HuffmanTree::CreateHuffmanTree(HuffmanNode ** ppNode)
 {
     _ASSERT(pWeight || ppNode); //判断是否是空指针

     int nodeNum = *size-; //哈弗曼树总节点数
     if (nodeNum<=)
         return ; //出现错误退出函数
     pNode = new HuffmanNode [nodeNum];
     _ASSERT(pNode);
     for (int i= ; i<size ; ++i) //赋初值
     {
         pNode[i].weight = pWeight[i];
         pNode[i].flag = IN_FOREST;
     }
     int min1 = MAX_VALUE, min2 = MAX_VALUE; //最小值和次小值
     int pos1 = -, pos2 = -; //最小值和次小值位置
     for (int i= ; i<size ; ++i) //遍历所有节点并且赋值
     {
         for (int j= ; j<nodeNum ; ++j) //查找最小值和次小值
         {
             if (pNode[j].flag==IN_FOREST && pNode[j].weight<min1)
             {
                 min2 = min1;
                 pos2 = pos1;
                 min1 = pNode[j].weight;
                 pos1 = j;
             }
             else if (pNode[j].flag==IN_FOREST && pNode[j].weight<min2)
             {
                 min2 = pNode[j].weight;
                 pos2 = j;
             }
         }
         if (-!=pos1 && -!=pos2)
         {
             //生成最小值和次小值的二叉树双亲
             pNode[size+i].weight = (pNode[pos1].weight+pNode[pos2].weight);
             pNode[size+i].flag = IN_FOREST;
             pNode[size+i].lChild = &pNode[pos1];
             pNode[size+i].rChild = &pNode[pos2];
             pNode[pos1].flag = OUT_FOREST;
             pNode[pos1].parent = &pNode[size+i];
             pNode[pos2].flag = OUT_FOREST;
             pNode[pos2].parent = &pNode[size+i];
 #ifdef NODEBUG
             cout << "pNode[" << (size+i) << "].weight = " << pNode[size+i].weight << endl;
             cout << "pNode[" << (size+i) << "].flag = " << pNode[size+i].flag << endl;
             cout << "pNode[" << (size+i) << "].parent = " << pNode[size+i].parent << endl;
             cout << "pNode[" << (size+i) << "].lChild = " << pNode[size+i].lChild << endl;
             cout << "pNode[" << (size+i) << "].rChild = " << pNode[size+i].rChild << endl;
             cout << "pNode[" << (pos1) << "].weight = " << pNode[pos1].weight << endl;
             cout << "pNode[" << (pos1) << "].flag = " << pNode[pos1].flag << endl;
             cout << "pNode[" << (pos1) << "].parent = " << pNode[pos1].parent << endl;
             cout << "pNode[" << (pos1) << "].lChild = " << pNode[pos1].lChild << endl;
             cout << "pNode[" << (pos1) << "].rChild = " << pNode[pos1].rChild << endl;
             cout << "pNode[" << (pos2) << "].weight = " << pNode[pos2].weight << endl;
             cout << "pNode[" << (pos2) << "].flag = " << pNode[pos2].flag << endl;
             cout << "pNode[" << (pos2) << "].parent = " << pNode[pos2].parent << endl;
             cout << "pNode[" << (pos2) << "].lChild = " << pNode[pos2].lChild << endl;
             cout << "pNode[" << (pos2) << "].rChild = " << pNode[pos2].rChild << endl;
 #endif //DEBUG
             //重置最小值和次小值
             min1 = min2 = MAX_VALUE;
             //重置最小值和次小值位置
             pos1 = pos2 = -;
         }
         if (i==size-)
         {
             pNode[size+i-].flag = OUT_FOREST;
         }
 #ifdef NODEBUG
         cout << "node [] = {" << setw(WIDTH) << "weight" << setw(WIDTH) << "flag" << endl;
         for (int k= ; k<nodeNum ; ++k)
         {
             cout << setw() << " ";
             cout << setw(WIDTH) << (pNode[k].flag== ? "IN_FOREST" : "OUT_FOREST") << setw(WIDTH) << pNode[k].weight << endl;
         }
         cout << setw() << "}" << endl;
 #endif //DEBUG
     }
 #ifdef NODEBUG
     for (int k= ; k<nodeNum ; ++k)
     {
         cout << "pNode[" << (k) << "].weight = " << pNode[k].weight << endl;
         cout << "pNode[" << (k) << "].flag = " << pNode[k].flag << endl;
         cout << "pNode[" << (k) << "].parent = " << pNode[k].parent << endl;
         cout << "pNode[" << (k) << "].lChild = " << pNode[k].lChild << endl;
         cout << "pNode[" << (k) << "].rChild = " << pNode[k].rChild << endl;
     }
 #endif //DEBUG
     *ppNode = pNode;
 }

 //************************************
 // Method:    GetHuffmanCode
 // FullName:  HuffmanTree::GetHuffmanCode
 // Access:    public
 // Returns:   void
 // Qualifier: 创建哈夫曼编码，返回指向哈弗曼编码数组的指针（注：调用该函数前一定要先使用函数CreateHuffmanTree）
 // Parameter: HuffmanNode * pNode
 // Parameter: HuffmanCode * * ppCode
 //************************************
 void HuffmanTree::GetHuffmanCode(HuffmanNode * pNode, HuffmanCode ** ppCode)
 {
     _ASSERT(pNode || ppCode);
     if (size<=)
         return ; //终止函数执行
 #ifdef NODEBUG
     for (int k= ; k<size*- ; ++k)
     {
         cout << "pNode[" << (k) << "].weight = " << pNode[k].weight << endl;
         cout << "pNode[" << (k) << "].flag = " << pNode[k].flag << endl;
         cout << "pNode[" << (k) << "].parent = " << pNode[k].parent << endl;
         cout << "pNode[" << (k) << "].lChild = " << pNode[k].lChild << endl;
         cout << "pNode[" << (k) << "].rChild = " << pNode[k].rChild << endl;
     }
 #endif //DEBUG

     pCode = new HuffmanCode [size];
     _ASSERT(pCode);

     for (int i= ; i<size ; ++i) //赋值操作
     {
         pCode[i].weight = pWeight[i]; //权值赋值
         int pCode_Length = ; //临时变量
         HuffmanNode * temp = &pNode[i]; //临时变量
         while (NULL!=temp->parent)
         {
             ++pCode_Length;
             temp = temp->parent;
         }
         pCode[i].pathLength = pCode_Length; //路径长度赋值
         pCode[i].pPath = new int [pCode[i].pathLength]; //路径数组创建
         temp = &pNode[i]; //重新复制临时变量
         for (int j=pCode_Length- ; j>= ; --j) //路径数组赋值
         {
             if (NULL!=temp->parent)
             {
                 HuffmanNode * putValue1 = temp->parent->lChild; //DEBUG
                 HuffmanNode * putValue2 = temp->parent->lChild; //DEBUG
                 if (temp==temp->parent->lChild)
                     pCode[i].pPath[j] = LEFTCHILD;
                 else
                     pCode[i].pPath[j] = RIGHTCHILD;
                 temp = temp->parent;
             }
         }
 #ifdef NODEBUG
         cout << "code [] = {" << setw(WIDTH) << "weight" << setw(WIDTH) << "pPath" << endl;
         cout << setw() << " ";
         cout << setw(WIDTH) << pCode[i].weight << ", ";
         cout << setw() << " ";
         for (int k= ; k<pCode_Length ; ++k)
             cout << pCode[i].pPath[k] << ",";
         cout << endl;
 #endif //DEBUG
     }
 #ifdef NODEBUG
     for (int k= ; k<size*- ; ++k)
     {
         cout << "pNode[" << (k) << "].weight = " << pNode[k].weight << endl;
         cout << "pNode[" << (k) << "].flag = " << pNode[k].flag << endl;
         cout << "pNode[" << (k) << "].parent = " << pNode[k].parent << endl;
         cout << "pNode[" << (k) << "].lChild = " << pNode[k].lChild << endl;
         cout << "pNode[" << (k) << "].rChild = " << pNode[k].rChild << endl;
     }
 #endif //DEBUG
     *ppCode = pCode;
 }

 //************************************
 // Method:    FreeHuffmanTree
 // FullName:  FreeHuffmanTree
 // Access:    public
 // Returns:   void
 // Qualifier: 销毁由函数CreateHuffmanTree申请的对象
 // Parameter: HuffmanNode * * ppNode
 //************************************
 void FreeHuffmanTree(HuffmanNode ** ppNode)
 {
     if (NULL!=ppNode && NULL!=*ppNode)
     {
         delete [] *ppNode;
         *ppNode = NULL;
     }
 }

 //************************************
 // Method:    FreeHuffmanTree
 // FullName:  FreeHuffmanTree
 // Access:    public
 // Returns:   void
 // Qualifier: 销毁由函数GetHuffmanCode申请的内存
 // Parameter: HuffmanCode * * ppCode
 //************************************
 void FreeHuffmanTree(HuffmanCode ** ppCode)
 {
     if (NULL!=ppCode && NULL!=*ppCode)
     {
         int size = _msize(*ppCode)/sizeof(HuffmanCode);
         for (int i= ; i<size ; ++i)
         {
             if (NULL!=(*ppCode+i)->pPath)
             {
                 delete [] (*ppCode+i)->pPath;
                 (*ppCode+i)->pPath = NULL;
             }
         }
         delete [] *ppCode;
         *ppCode = NULL;
     }
 }

Main.cpp

 #include <iostream>
 #include "HuffmanTree.h"

 using namespace std;

 #define DEBUG

 #define _CRTDBG_MAP_ALLOC
 #include <stdlib.h>
 #include <crtdbg.h>

 #ifndef DBG_NEW
 #define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )
 #define new DBG_NEW
 #endif

 int main() //测试代码
 {
     ::_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
     ::_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
     ::_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDOUT);

     int weight[] = {, , , , , , };
     int size = sizeof(weight)/sizeof(int);
 #ifdef DEBUG
     cout << "weight [] = {" ;
     for (int i= ; i<size ; ++i)
         cout << weight[i] << ", " ;
     cout << "}" << endl;
 #endif //DEBUG
     HuffmanTree obj(weight, size);
     HuffmanNode * pNode = NULL;
     obj.CreateHuffmanTree(&pNode);
     HuffmanCode * pCode = NULL;
     obj.GetHuffmanCode(pNode, &pCode);

     FreeHuffmanTree(&pNode);
     FreeHuffmanTree(&pCode);

     return ;
 }

以上程序共5个文件：

1.Main.cpp文件主要实现对哈弗曼树、哈弗曼编码的测试，并且使用VS专用内存泄露检测代码进行内存泄露检测；

2.类HuffmanNode主要实现哈弗曼节点结构构造；

3.类HuffmanCode主要实现对哈弗曼树路径的存储；

4.类HuffmanTree主要实现哈弗曼树，并且实现创建哈弗曼树，创建哈弗曼编码；

5.使用宏#define DEBUG来对哈弗曼类代码中间结果进行验证。