Huffman编码的实现

      这里的Huffman编码就是离散数学中学的最优二叉树，现在我们用C++来实现它。

      首先考虑实现它使用的数据结构，当然这里肯定使用二叉树。其次就是存储方式，对于树一般情况是用间接存储也就是链表。但是二叉链表不方便寻找双亲节点，这里使用向量更好，对存储空间的利用率也较高。

  建立数据结构：

       Huffman树中每个节点看成数组中的一个元素，它的属性有：权(weight),字符(data) 。为了方便寻找双亲和孩子节点加入三个域parent ,lch ,rch。分别存储双亲和左右孩子节点在数组中位置下标。

       然后再建立个类来操作Huffman树。

//Huffman.h
#include <string>
using std::string;

class HuffmanTree
{
public:
   HuffmanTree(int,int[]);
    
   void BuildTree();
   void SetCode();
   void Display();
   string Send(char*);
   string Get(string);
    
private:
   void Select(int,int&,int&);
    
private:    
    class Node
    {
         friend class HuffmanTree;
         int weight;
         char data;
         string code;
         int parent,lchild,rchild;
     }*nodes;
      int codenum;
      int nodenum;
};

        这里，我在节点中又加了个code属性，这个是每个字符的最后编码。codenum是叶子节点数，也就是需要编码的字符节点数。nodenum是总节点数。要让外面那个类能操作Node类，则需要声明为它的友元函数。

        Huffman数建立的过程：

        1. 根据给定的n个权值构成n棵二叉树。

        2. 从所有的二叉树中选取两个权值最小节点的构成一个新的树，这个树的权值是两个节点权值之和。

        3. 重复2，直到只剩一棵树为止。

 下面是实现这个类的代码：

//Huffman.cpp
#include "Huffman.h"
#include <iostream>
#include <string>
using namespace std;

HuffmanTree::HuffmanTree(int num,int w[]):codenum(num)
{
      nodenum=2*codenum-1;
      nodes=new Node[nodenum];
      for(int i=0;i<codenum;i++)
      {
            nodes[i].weight=w[i];
            nodes[i].data='a'+i;
            nodes[i].parent=nodes[i].lchild=nodes[i].rchild=-1;
            nodes[i].code="";
      }
      for(int i=codenum;i<nodenum;i++)
      {
            nodes[i].weight=0;
            nodes[i].data=0;
            nodes[i].parent=nodes[i].lchild=nodes[i].rchild=-1;
     }
}

void HuffmanTree::BuildTree()
{
       for(int i=codenum;i<nodenum;i++)
      {
             int s1=0,s2=0;
             Select(i,s1,s2);
             nodes[s1].parent=nodes[s2].parent=i;
             nodes[i].lchild=s1;
             nodes[i].rchild=s2;
             nodes[i].weight=nodes[s1].weight+nodes[s2].weight;
       }        
}

void HuffmanTree::Select(int size,int& s1,int& s2)
{
      int temp=0;    
      for(int i=0;i<size;i++)
      {
             if(nodes[i].parent!=-1)
    continue;
             if(temp==0)
             {
    s2=i;
    temp++;
    continue;
             }
             if(temp==1)
             {
    if(nodes[i].weight>nodes[s2].weight)
    {
            s1=s2;
            s2=i;
    }
    else
            s1=i;
    temp++;
    continue;
             }
             if(nodes[i].weight<nodes[s2].weight)
             {
    if(nodes[i].weight<nodes[s1].weight)
    {
            s2=s1;
            s1=i;
    }                
    else
            s2=i;
             }
      }
}

void HuffmanTree::SetCode()
{
        for(int i=0;i<codenum;i++)
        {
                int j=i;
                int p=nodes[j].parent;
                while(p!=-1)
                {
       if(nodes[p].lchild==j)
                 nodes[i].code="0"+nodes[i].code;
      else
                nodes[i].code="1"+nodes[i].code;
       j=p;
       p=nodes[j].parent;
                 }    
        }
}

void HuffmanTree::Display()
{
       for(int i=0;i<codenum;i++)    
            cout<<nodes[i].data<<":   weight = "<<nodes[i].weight<<": "<<nodes[i].code<<endl;
}

string HuffmanTree::Send(char* old)
{
        string newcode="";
        for(;*old;old++)
       {
              for(int i=0;i<codenum;i++)
             {
    if(nodes[i].data==*old)
    {
             newcode+=nodes[i].code;
             break;
    }
             }
        }
        return newcode;
}

string HuffmanTree::Get(string old)
{
        string newcode="";
        string::size_type index=0;
        int treeindex=nodenum-1;
        while(index<=old.size())
        {
              if(nodes[treeindex].lchild==-1)
              {
    newcode+=nodes[treeindex].data;
    treeindex=nodenum-1;
              }
              else
             {
    if(old[index]=='0')
            treeindex=nodes[treeindex].lchild;
    else
            treeindex=nodes[treeindex].rchild;
    index++;
              }        
          }
         return newcode;
}

    构造函数：用待编码字符数和每个字符的权值来初始化。
                       根据节点个数在堆区建立数组。
                       节点分两种叶子节点(为编码的字符)和非叶子节点，所以分开初始化。

    Build 函数：这个是根据Huffman树规则建立二叉树。

    Select 函数：从节点数组0到size的范围内选取两个权值最小的节点，下标放在s1,s2中。

    SetCode 函数：求出每个字符的编码。

    Display 函数：显示编码。

    Send 函数：给定一个字符串，求出它的编码。

    Get 函数：从得到的0、1串中翻译出它原编码。

    编码的过程就是从树叶到树根的路径，而反编码则是从树根到树叶的路径。

最后给出一个测试代码： 

//The test file
#include <iostream>
#include <string>
#include "Huffman.h"

using namespace std;

int main()
{
      int w[]={5,29,7,8,14,23,3,11,12,9,20,17,13,57,32};
      HuffmanTree* t=new HuffmanTree(15,w);
       t->BuildTree();
       t->SetCode();
       t->Display();
       char s[]="aefbcgbam";
       string p=t->Send(s);
       cout<<p<<endl;
       cout<<t->Get(p)<<endl;
}

        最后说一点，操作字符串在C++中，使用标准库中的string类比自己来拨弄指针方便多了，大家以后多试着用下，可以发现它的很多好处。