实现字符串的哈夫曼编码（取自某博主）

代码如下（注释非常详细）：

#include<bits/stdc++.h>
using namespace std;

#define N 50     //叶子结点数

//结点定义
typedef struct {
    char data;//元素类型
    int value;//元素权值
    int parent;
    int lchild;
    int rchild;
}HF_node;

//每个元素的赫夫曼编码
typedef struct {
    char code[N];      //存放赫夫曼编码，最多为N，一般前面位置都空余
    int index;       //记录每个字母编码在code数组里开始的位置，从n逐渐往前增加编码
}HF_code;

//构造n个叶子结点的赫夫曼树
void createHfTree(HF_node hfTree[],int n)
{
    int min_value1,min_value2;    //存放目前最小权值的两个结点
    int lnode,rnode;//lnode与min_value1对应，rlnode与min_value2对应
    //将所有结点的左右孩子以及父节点指针置为NULL
    for(int i = 0; i < 2*n-1; i++){
        hfTree[i].parent = hfTree[i].lchild = hfTree[i].rchild = -1;//-1即为空
    }
    //数组前n-1个元素是叶子节点，从n开始逐步加入新和成的节点，直到最后
    for(int i = n; i < 2*n-1; i++)
    {
        min_value1 = min_value2 = 99999;     //每次循环时都将min初始化
        lnode = -1;     //lnode存最小的，rnode存次小的
        rnode = -1;
        //遍历此时的前i-1个节点，找到最小的两个合并后放入i位置
        for(int k = 0; k < i; k++)
        {//规则就是每次循环找到一个最小的先把值给min1，min1的值就顺位给min2，同时更换lnode和rnode的值记录此时位置
            //如果找到比min1大但比min2小的则仅仅更换min2的相关即可
            if(hfTree[k].parent == -1)   //没有父结点的才判断
            {   //首先此节点的权值先与min1比较，匹配不成功再和min2比较
                if(hfTree[k].value < min_value1)
                {
                    min_value2 = min_value1;
                    rnode = lnode;   //有比min1还小的，原min1就变成了次小的，赋给min2
                    min_value1 = hfTree[k].value;//最小的赋值给min1
                    lnode = k;//左节点记录此时最小权值节点位置
                }
                else if(hfTree[k].value < min_value2)
                {
                    min_value2 = hfTree[k].value;
                    rnode = k;
                }
            }
        }
        //上述循环完成，表示此时已经找到了目前前i-1个元素中的最小和次小，填加ht数组的i位置节点即可
        //并且设置好相关的左右孩子坐标以及父节点坐标
        hfTree[lnode].parent = i;
        hfTree[rnode].parent = i;
        hfTree[i].value = hfTree[lnode].value + hfTree[rnode].value;
        hfTree[i].lchild = lnode;
        hfTree[i].rchild = rnode;
    }
}

//构造赫夫曼编码
void createHfCode(HF_node hfTree[],HF_code hfCode[],int n)
{
    int p_node,f_node;//p_node在某条编码支路上一直作为枢纽，f_node一直作为父节点
    HF_code code;//记录每个字符的编码
    for(int i = 0; i < n; i++)
    {
        code.index = n;
        p_node = i;//p_node是每个字符这条编码支路上的节点过渡点，通过p_node每次判断此时节点是父亲的左孩子还是右孩子
        f_node = hfTree[i].parent;
        while (f_node != -1)//不是-1就一直往上找，直到找到最后一层
        {
            if(hfTree[f_node].lchild == p_node)
                code.code[code.index--] = '0';//从后往前依次加入哈夫曼编码,左孩子给‘0’
            else
                code.code[code.index--] = '1';//右孩子给‘1’
            p_node = f_node;//父节点给枢纽，准备继续往上找
            f_node = hfTree[f_node].parent;//父节点更新为上一个父节点的父节点
        }
        code.index++;//index++后，index才作为此时编码的第一个数值，前面可能有空位
        hfCode[i] = code;
    }
}


void print(HF_node hfTree[],HF_code hfCode[],int n)    //输出赫夫曼编码
{
    for(int i = 0; i < n; i++)//从0到n-1准备输出各个元素的哈夫曼编码
    {
        cout<<hfTree[i].data<<": ";
        for(int j = hfCode[i].index; j <= n; j++)//编码从index位开始，到n结束
            cout<<hfCode[i].code[j];//从有效位开始依次输出每个哈夫曼编码
        cout<<endl;
    }
}



int main()
{
    int n;
    cin>>n;
    //赫夫曼树中总结点数 = 2*n-1，其实就是在原有元素个数上再进行n-1次运算组合，多出n-1个节点，因此总点数为2n-1
    HF_node hfTree[2*n-1];
    HF_code hfCode[n];   //定义有n个结点的赫夫曼编码数组

    for(int i = 0; i < n; i++)
    {
        cin>>hfTree[i].data>>hfTree[i].value;
    }
    for(int i = 0; i < n; i++)
    {
        cout << hfTree[i].data << " " <<hfTree[i].value << " ";
    }
    cout << "\n";
    createHfTree(hfTree,n);
    createHfCode(hfTree,hfCode,n);
    print(hfTree,hfCode,n);
}