数据结构c+python代码6：哈夫曼树构造及编码

首先介绍一下什么是哈夫曼树？
给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。

哈夫曼树又称为最优树.
1、路径和路径长度
在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。
2、结点的权及带权路径长度
哈夫曼树
哈夫曼树(3张)
若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积。
3、树的带权路径长度
树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WPL。

哈夫曼树的构造
假设有n个权值，则构造出的哈夫曼树有n个叶子结点。 n个权值分别设为 w1、w2、…、wn，则哈夫曼树的构造规则为：
(1) 将w1、w2、…，wn看成是有n 棵树的森林(每棵树仅有一个结点)；
(2) 在森林中选出两个根结点的权值最小的树合并，作为一棵新树的左、右子树，且新树的根结点权值为其左、右子树根结点权值之和；
(3)从森林中删除选取的两棵树，并将新树加入森林；
(4)重复(2)、(3)步，直到森林中只剩一棵树为止，该树即为所求得的哈夫曼树。

c代码过程分析
构造哈夫曼树算法的实现可以分成两大部分：
1、初始化：首先动态申请2n个单元；然后循环2n-1次，从1号单元开始，依次将1至2n-1所有单元中的双亲、左孩子、右孩子的下标都初始化为0；最后再循环n次，输入前n个单元中叶子节点的权值。
2、创建树：循环n-1次，通过n-1次的选择、删除与合并来创建哈夫曼树。选择是从当前森林中选择双亲为0且权值最小的两个树跟节点是s1和s2；删除是指将节点s1和s2的双亲改为非0；合并就是将s1和s2的权值和作为一个新节点的权值依次存入到数组的第n+1之后的单元中，同时记录这个新节点左孩子的下标为s1，右孩子的下标为s2。

哈夫曼编码的算法实现
在构造哈夫曼树之后，求哈夫曼编码的主要思想是：依次以叶子为出发点，向上回溯至根节点为止。回溯时走左分支则生成代码0，走右分支则生成代码1。
由于每个哈夫曼编码是变长编码，因此使用一个指针数组来存放每个每个字符编码串的首地址。
**typedef char HuffmanCode; //动态分配数组存储哈夫曼编码表
各字符的哈夫曼编码存储在由HuffmanCode定义的动态分配的数组HC中，为了实现方便，数组的0号单元不使用。从1号单元开始使用，所以数组HC的大小为n+1.即编码表HC包括n+1行。但是因为每个字符编码的长度事先不能确定，所以不能预先为每个字符分配大小合适的存储空间。为了不浪费存储空间，动态分配一个长度为n（字符编码一定小于n）的一维数组cd，用来临时存放当前正在求解的第i（1<=i<=n）个字符的编码，当第i个字符的编码求解完毕后，根据数组cd的字符串长度分配HC[i]的空间，然后将数组cd中的编码复制到HC[i]中。
因为求解编码时是从哈夫曼树的叶子出发，向上回溯至根节点。所以对于每个字符，得到的编码顺序是从右向左的，故将编码向数组cd存放的顺序也是从后向前的，即每个字符的第1个编码存放在cd[n-2]中（cd[n-1]存放字符串结束标志‘\0’），第2个编码存放在cd[n-3]中，依次类推，直到全部编码存放完毕。
其他的我就不多说了，直接放代码，c语言实现哈夫曼树的构造及编码如下：

#include <iostream>
using namespace std;
#include <stdlib.h>
typedef char **HuffmanCode;
#include <string.h>

typedef struct HTNode
{
    int weight;    
    int parent, lchild, rchild;
}HTNode, *HuffmanTree;

void Select(HuffmanTree HT, int n, int &s1, int &s2)
{
    int minum;    //定义一个临时变量保存最小值
    for(int i=1;i<=n;i++)   //寻找第一个最小值 
    {
        if(HT[i].parent==0)
        {
            minum = i;
            break;
        }
    } 
    for(int i=1;i<=n;i++)
    {
        if(HT[i].parent==0)
        {
            if(HT[i].weight < HT[minum].weight)
            {
                minum = i;
            }
        }
    }
    s1 = minum;
    
    for(int i=1;i<=n;i++)  //寻找第二个最小值 
    {
        if(HT[i].parent==0&&i!=s1)
        {
            minum = i;
            break;
        }
    }    
    for(int i=1;i<=n;i++)
    {
        if(HT[i].parent==0&&i!=s1)
        {
            if(HT[i].weight < HT[minum].weight)
            {
                minum = i;
            }
        }
    } 
    s2 = minum;
}


void creatHuff(HuffmanTree &HT, int *w, int n)
{
    int m, s1, s2;
    m = 2*n-1;      //总的节点个数
    HT = (HTNode *)malloc(sizeof(HTNode)*(m+1));
    for(int i=1;i<=n;i++)  //1-n之间存放叶子节点 初始化 
    { 
        HT[i].weight = w[i];
        HT[i].parent = 0;
        HT[i].lchild = 0;
        HT[i].rchild = 0;
    }
    
    for(int i=n+1;i<=m;i++)   //非叶子节点的初始化 
    {
        HT[i].weight = 0;
        HT[i].parent = 0;
        HT[i].lchild = 0;
        HT[i].rchild = 0;
    }
    
    cout<<"构造的哈夫曼树如下：\n";
    for(int i=n+1;i<=m;i++)   //填充n+1-m之间节点的信息 
    {
        //在HT[1]-HT[i-1]的范围内选择两个parent为0且weight最小的两个节点，其序号分别赋值给s1 s2 
        Select(HT, i-1, s1, s2); 
        HT[s1].parent = i;
        HT[s2].parent = i;
        HT[i].lchild = s1;
        HT[i].rchild = s2;
        HT[i].weight = HT[s1].weight + HT[s2].weight;
        printf("%d (%d, %d)\n", HT[i].weight, HT[s1].weight, HT[s2].weight);
    }
    
//    cout<<"根节点的标号-权重-左孩子标号-右孩子标号：\n";
//    for(int i=n+1;i<=m;i++){
//        if(HT[i].parent==0){
//            printf("%d-%d-%d-%d", i, HT[i].weight, HT[i].lchild, HT[i].rchild);
//        }
//    }
}


void CreatHuffmanCode(HuffmanTree HT, HuffmanCode &HC, int n)
{
    HC = (char **)malloc(sizeof(char *)*(n+1)); //分配n个字符编码的编码表空间 
    char *cd = (char *)malloc(sizeof(char)*n);  //分配临时存放每个字符编码的动态数组空间 
    cd[n-1] = '\0';
    int start, c, f;
    for(int i=1;i<=n;i++)
    {
        start = n-1;
        c = i;
        f = HT[i].parent;
        while(f!=0)
        {
            start --;
            if(HT[f].lchild == c)
                cd[start] = '0';
            else
                cd[start] = '1';
            c = f;
            f = HT[f].parent;
        }
        HC[i] = (char *)malloc(sizeof(char)*(n-start));
        strcpy(HC[i], &cd[start]);
    } 
    delete cd;
    for(int i=1;i<=n;i++){
        cout<<"编号"<<i<<": 权重为"<<HT[i].weight<<"编码为："<<HC[i]<<endl; 
    }
    delete HT;
}
int main()
{
    HuffmanTree HT;
    int n, wei;
    cout<<"请输入节点的个数：";
    cin>>n;
    int *w = (int *)malloc(sizeof(int)*(n+1));
    cout<<"请输入"<<n<<"个节点的weight:"<<endl;
    for(int i=1;i<=n;i++)
    {
        cin>>wei;
        w[i] = wei;
    }
    
    creatHuff(HT, w, n);
    
    HuffmanCode HC; 
    CreatHuffmanCode(HT, HC, n);
    delete w;
    
    return 0;
} 

相同的思想用python来实现出来，代码如下：

def Int(w):
    for i in range(0, len(w)):
        w[i] = int(w[i])
    return w

def Select(tree, n):
    minum = 0                 #寻找第一个权重最小的下标
    for i in range(0, n+1):
        if tree[i]["parent"] == -1:
            minum = i
            break
    for i in range(0, n+1):
        if tree[i]["parent"] == -1:
            if tree[i]["weight"] < tree[minum]["weight"]:
                minum = i
    s1 = minum
    for i in range(0, n+1):        #寻找第二个权重最小的下标
        if tree[i]["parent"] == -1 and i != s1:
            minum = i
            break

    for i in range(0, n+1):
        if tree[i]["parent"] == -1 and i != s1:
            if tree[i]["weight"] < tree[minum]["weight"]:
                minum = i
    s2 = minum
    return s1, s2

def CreatHuffmanTree(w, n):
    m = 2*n-1
    tree = []
    for i in range(0, n):            #先将叶子节点的各个信息放入到集合中
        node = {"weight": w[i], "parent": -1, "lchild": 0, "rchild": 0}
        tree.append(node)
    for i in range(n, m):        #把非叶子节点的各个信息放入到集合中
        node = {"weight": 0, "parent": -1, "lchild": 0, "rchild": 0}
        tree.append(node)

    for i in range(n, m):   #填充n~m-1之间节点的信息
        s1, s2 = Select(tree, i-1)           #在0~i-1的范围内选择两个parent为0且weight最小的两个节点，其序号分别赋值给s1 s2
        tree[s1]["parent"] = i
        tree[s2]["parent"] = i

        tree[i]["lchild"] = s1
        tree[i]["rchild"] = s2
        tree[i]["weight"] = tree[s1]["weight"] + tree[s2]["weight"]
    return tree

def printTree(tree):
    print("构建哈夫曼树如下：")
    index = 0
    for i in tree:
        print(index, i)
        index += 1

def inverse(codes):

    for i in range(0, len(codes)):
        res = ""
        for k in range(len(codes[i])-1, -1, -1):
            res += codes[i][k]
        codes[i] = res
    return codes

def CreatHuffmanCode(tree, n):
    code = ""
    for i in range(0, n):
        c = i
        f = tree[i]["parent"]
        while f != -1:
            if tree[f]["lchild"] == c:
                code += "0"
            else:
                code += "1"
            c = f
            f = tree[f]["parent"]
        if i != n-1:
            code += "\n"
    codes = code.split("\n")
    #print(codes)
    codes = inverse(codes)
    print("---------编码如下----------------")
    for i in range(0, len(codes)):
        print("权值为{}的叶子节点编码：{}".format(tree[i]["weight"], codes[i]))

if __name__ == '__main__':
    n = int(input("请输入节点的个数："))
    w = input("请输入{}个节点的权值：".format(n)).split(" ")
    w = Int(w)
    HuffmanTree = CreatHuffmanTree(w, n)   #创建哈夫曼树
    printTree(HuffmanTree)
    CreatHuffmanCode(HuffmanTree, n)

有什么问题的话可以在下方留言，如果能够帮助到你，希望能帮忙点个赞！！！蟹蟹喽！！！