赫夫曼树相关算法

参考书籍 ：数据结构C语言版

一、基础知识：

（1）最优二叉树（赫夫曼树）的介绍：

a、路径长度：从树中一个结点到另一个结点之间的分支构成这两个结点之间的路径，路径上分支数目称做路径长度。

b、树的路径长度：从树根到每一个结点之间的路径长度之和。上一篇介绍的完全二叉树就是这种路径长度最短的二叉树。

c、带权路径长度：结点的带权路径长度为从该结点到树根之间的路径产度与结点上权的乘积。树的带权路径长度为树中所有叶子结点的带权路径长度之和，通常记作WPL。

d、最优二叉树（赫夫曼树）：假设有n个权值w1，w2，···wn，试构造一棵有n个叶子结点的二叉树，每个叶子结点带权为wi，则其中带权路径长度WPL最小的二叉树称做最优二叉树或赫夫曼树。

 

（2）构造赫夫曼树：

1、根据给定的n个权值{w1，w2，···wn}构成 n棵二叉树的集合F={T1，T2，···Tn},其中每个二叉树Ti中只有一个带权为wi的根结点，其左右子树均为空。

2、选择两棵根结点的权值最小的输作为左右子树构造一棵新的二叉树，且置新的二叉树的根结点的权值为其左、右子树上的根结点的权值之和。

3、在F中删除这两棵树，同时将新得到的二叉树加入F中。

4、重复2和3，直到F只含一棵树为止。这棵树便是赫夫曼树。

 

（3）赫夫曼编码

       目前，进行快速远距离通信的主要手段是电报，即将需传送的文字转换成由二进制的字符组成的字符串。当然，在传送电文时，希望总长尽可能地短。如果对每个字符设计长度不同的编码，且让电文中出现次数较多的字符采用尽可能短的编码，则传送电文的总长便可减少。因此，若要设计长短不等的编码，则必须是任一个字符的编码都不是另一个字符的编码的前缀，这种编码称做前缀编码。

      那么，如何得到使电文最短的二进制前缀编码呢？ 假设每种字符在电文中出现的次数为wi，其编码长度为li，电文中只有n中字符，则电文总长为w1*l1+w2*l2+···wn*ln。对应到二叉树上，若置wi为叶子结点的权，li恰为从根到叶子的路径长度。则w1*l1+w2*l2+···wn*ln恰为二叉树的带权路径长度。由此可见，设计电文总长最短的二进制前缀编码即为以n中字符出现的频率作权，设计一棵赫夫曼树的问题，由此得到的二进制前缀编码便称为赫夫曼编码。

二、算法分析设计：

由于赫夫曼树中没有度为1的结点（又称为正则二叉树），则一棵有n个叶子结点的赫夫曼树共有2n-1个结点，可以存储在一个大小为2n-1的一维数组中。如何选定结点结构？由于在构成赫夫曼树之后，为求编码需从叶子结点出发走一条从叶子到根的路径；而为译码需从根出发走一条从根到叶子的路径。则对每个结点而言，既需要知道双亲的信息，又需要知道孩子结点的信息，由此，设定如下的存储结构：

struct HNode{      //赫夫曼树结点数据结构
    int parent;
    int lchild;
    int rchild;
    int weight;
}; 、


算法如下

#include "stdafx.h"

#include <iostream>
#define N 8
#define infinity 32767
using namespace std;

struct HNode{      //赫夫曼树结点数据结构
    int parent;
    int lchild;
    int rchild;
    int weight;
};
HNode HT[2 * N];      //赫夫曼树的一维数组存储结构（共需要2n-1个单元，n个叶子，n-1个度为2的结点，第0个单元未用）

struct CodeType{   //单个赫夫曼编码数据结构
    int start;
    char bits[N + 1];      //第0个单元未用
};

struct HCode{
    char data;
    CodeType code;
};
HCode HC[N + 1];      //赫夫曼编码表

void select(int s, int &x1, int &x2)   //选出parent为0且weight最小的两个结点
{
    int v1, v2;
    v1 = v2 = infinity;
    x1 = x2 = 0;
    for (int i = 1; i <= s; ++i)
    {
        if (HT[i].parent == 0)
        {
            if (HT[i].weight < v1)
            {
                v2 = v1;
                x2 = x1;
                v1 = HT[i].weight;
                x1 = i;
            }
            else if (HT[i].weight < v2)
            {
                x2 = i;
                v2 = HT[i].weight;
            }
        }
    }
}
void set_huftree()         //创建赫夫曼树
{
    int s1=0, s2=0;
    for (int i = 1; i <= 2*N-1; ++i)
    {
        HT[i].parent = HT[i].lchild = HT[i].rchild = 0;
    }
    //建立赫夫曼树
    for (int i = N + 1; i <= 2 * N-1; ++i)
    {
        select(i - 1, s1, s2);   //选择parent为0且weight最小的两个结点，序号分别为s1和s2，用于构造新的二叉树
        HT[s1].parent = HT[s2].parent = i;
        HT[i].lchild = s1;
        HT[i].rchild = s2;
        HT[i].weight = HT[s1].weight + HT[s2].weight;
    }
}

//从叶子到根逆向求每个字符的赫夫曼编码
void set_hufcode()
{
    CodeType c;
    int f, s;
    for (int i = 1; i <= N; ++i)
    {
        c.start = N + 1;
        for (s = i, f = HT[s].parent; f != 0; s = f, f = HT[s].parent)
        {
            c.start--;
            if (s == HT[f].lchild)
                c.bits[c.start] = '0';
            else
                c.bits[c.start] = '1';
        }
        HC[i].code = c;
    }
}

//从根到叶子输出赫夫曼编码
void print_hufcode()
{
    CodeType c;
    cout << "输入8个字符:" << endl;
    for (int i = 1; i <= N; ++i)
    {
        cin >> HC[i].data;
    }
    cout << "输入8个字符的权值：" << endl;
    for (int i = 1; i <= N; ++i)
    {
        cin>> HT[i].weight;
    }
    set_huftree();
    set_hufcode();
    for (int i = 1; i <= N; ++i)
    {
        c = HC[i].code;
        cout << HC[i].data << " -->";
        for (int j = c.start; j <= N; ++j)
        {
            cout << c.bits[j];
        }
        cout << endl;
    }

}
int _tmain(int argc, _TCHAR* argv[])
{
    //输出赫夫曼编码
    print_hufcode();

    return 0;
}