Huffman的应用_Huffman编码

 //最优二叉树
 #include <iostream>
 #include <iomanip>
 using namespace std;

 //定义结点类型
 //【weight | lchid | rchild | parent】
 //为了判定一个结点是否已加入到要建立的哈夫曼树中
 //可通过parent域的值来确定.
 //初始时parent = -1，当结点加入到树中时，该结点parent的值
 //为其父亲结点在数组Huffman中的序号.
 template<typename T>
 struct HuffNode {
     T weight;             //权值
     int parent;           //指向父节点的指针域(结点元素的下标)
     int lch;              //左指针域
     int rch;              //右指针域
 }; 

 //哈夫曼树的构造算法
 template<typename T>
 HuffNode<T> *HuffmanTree(int n, const T& sign)     //生成最优二叉树
 {
     const int MAX_VALUE = ;
     int i, j, min1, min2, x1, x2;                  //min1为最小值, min2为次小值, x1位最小值下标, x2位次小值下标
     HuffNode<T> *ht = new HuffNode<T>[ * n - ];  //一个含有n个叶子结点的最优二叉树，总共有2*n-1个结点
     HuffNode<T> *huffNode = ht;
     for (i = ; i <  * n - ; i++)                //最优二叉树结点数组初始化
     {
         huffNode[i].weight = ;         //权值都设为0
         huffNode[i].parent = -;        //父节点，左右孩子结点
         huffNode[i].lch = -;
         huffNode[i].rch = -;           //都设置为-1,-1代表空
     }
     for (i = ; i < n; i++)             //依次输入n个叶子结点的权值
         cin >> huffNode[i].weight;

     for (i = ; i < n - ; i++)
     {
         min1 = min2 = MAX_VALUE;
         // x1, x2 用来保存找到的两个最小结点在数组中的位置
         x1 = x2 = ;
         for (j = ; j < n + i; j++) //因为外循环每循环一次，实际结点个数增加到n+i个
         {
             if (huffNode[j].weight < min1 && huffNode[j].parent == -)
             {
                 min2 = min1;                    //存在权值小于min1, 则min1赋值给次小值
                 x2 = x1;                        //次小值下标改变
                  min1 = huffNode[j].weight;      //当前权值赋值给最小值
                 x1 = j;                         //并保存最小值下标
             }
             else if (huffNode[j].weight < min2 && huffNode[j].parent == -)
             {
                 min2 = huffNode[j].weight;      //当前值赋值给次小值
                 x2 = j;                         //保存次小值下标
             }
         }
         //将找出的两个子树合并成一颗子树
         //对找到的两个最小结点的父指针域进行赋值
         huffNode[x1].parent = n + i;
         huffNode[x2].parent = n + i;
         //新合成树位置上的权值
         huffNode[n + i].weight = huffNode[x1].weight + huffNode[x2].weight;
         //两个最小结点的父结点的左右孩子域进行操作
         huffNode[n + i].lch = x1;
         huffNode[n + i].rch = x2;
     }
     return ht;
 } 

 template<typename T>
 void ShowHTree(HuffNode<T> *HT, int nodeNum)
 {
     HuffNode<T> *p = HT;
     int k;
     cout << "k" << "\t\t" << "Weight" << "\t\t" << "Parent"
          << "\t\t" << "Lchild" << "\t\t" << "Rchild" << endl;
     for (k = ; k <  * nodeNum - ; k++)
     {
         cout << k << "\t\t" << (p + k)->weight << "\t\t"
              << (p + k)->parent << "\t\t"
              << (p + k)->lch << "\t\t" << (p + k)->rch << endl;
     }
 } 

 /*************************编码*******************************/

 const int MAXBIT = ;     //定义Huffman编码的最大长度 

 //对于第i个字符，它的Huffman编码存放在Huffman[i].bit中的 从 Huffman[i].start 到 n 的分量中
 struct HCodeType {
     int bit[MAXBIT];         //用来保存字符 的 Huffman编码
     int start;               //start表示该编码在bit中的开始位置
 };

 void HuffmanCode(int n)
 {
     const int MAXODE = , MAXLEAF = ;      //最大编码长度，最多叶子数
     HuffNode<int> *huffNode;                  //用于 生成Huffman 编码
     HCodeType *huffCode, cd;
     int i, j, c, par, sign = ;

     huffNode = HuffmanTree(n, sign);          //建立Huffman树 

     huffCode = new HCodeType[n];              //初始化HuffCode
     for (int k = ; k < n; k++)
         huffCode[k].bit[i] = ;

     ShowHTree(huffNode, n);

     /**********************编码过程*************************/
     for (i = ; i < n; i++)                   //n--是叶结点数，不是全部结点数
     {
         cd.start = n - ;                     //从叶结点开始
         c = i;                                //c为 i的工作指针，以防误操作修改了 i
         par = huffNode[c].parent;
         while (par != -)                     //由叶结点向上直到树根
         {
             if (huffNode[par].lch == c)       //右子树编号 == c ==> 右是0标志
                 cd.bit[cd.start] = ;
             else                              //左是 1 标志
                 cd.bit[cd.start] = ;
             cd.start--;                      //开始位置向前
             c = par;                         //得到父亲结点的下标
             par = huffNode[c].parent;        //由叶结点向上直到树根 -- 得到父级点的父亲结点
         }
         for (j = cd.start + ; j < n; j++)   //保存求出的每个叶结点的哈夫曼编码和编码的起始位
         {
             huffCode[i].bit[j] = cd.bit[j];
         }
         huffCode[i].start = cd.start;        //设置编码的开始位置
     }

     //输出
     for (i =  ; i < n; i++)                 //输出每个叶子结点的哈夫曼编码
     {
         for (j = huffCode[i].start + ; j < n; j++) {
             cout << huffCode[i].bit[j] ;
         }
         cout << endl;
     }
 }

 int main()
 {
     int n;

     cout << "请输入叶子结点个数: " << endl;
     cin >> n;

     HuffmanCode(n);

     system("pause");

     return ;
 }