漫话算法：哈夫曼树与哈夫曼编码

1.哈夫曼树的存储方式

        哈夫曼树并不是真正意义上的树，它只是一个普通结构体，构建等操作也是在数组中完成的，所有这个结构体的元素有父元素，左节点元素，右节点元素，权重以及标志（叶子节点还是非叶子节点），哈夫曼树的原始节点全部为叶子节点，其余节点全靠后来添加

2.构造函数的的一部分：选择函数

        哈夫曼树的构建原则为将节点数组中权重最小和次小的挑出来，然后将它们的权重相加成为一个新的节点插入到节点数组中，左节点为最小的，右节点为次小的，重点是先要把这两个节点挑出来（必须是叶子节点）

void select(node v[], int n, int& s1, int& s2)
{
    int min = -1;
    for (int i = 0; i < n; i++)
    {
        if (v[i].parent == 0)
        {
            min = i;
            break;
        }
    }
    for (int i = min + 1; i < n; i++)
    {
        if (v[i].weight < v[min].weight && v[i].parent == 0)
        {
            min = i;
        }
    }
    s1 = min;
    for (int i = 0; i < n; i++)
    {
        if (v[i].parent == 0 && i != s1)
        {
            min = i;
            break;
        }
    }
    for (int i = min + 1; i < n; i++)
    {
        if (v[i].weight < v[min].weight && v[i].parent == 0)
        {
            min = i;
        }
    }
    s2 = min;
}

3.构造函数

        构造方法参考上面的选择函数

void build_huff(int n, huff v[], int len)
{
    int s1;
    int s2;
    for (int i = n; i < len; i++)
    {
        select(v, i, s1, s2);
        v[s1].parent = i;
        v[s2].parent = i;
        v[i].weight = v[s1].weight + v[s2].weight;
        v[i].lc = s1;
        v[i].rc = s2;
    }
}

4.给某个节点生成哈夫曼编码的函数

        某个节点的编码就是从根节点到该节点的路径，往左走一步加0，往右走一步加1，所以从下往上走，直到不存在父节点为止，将数据存在栈中的原因是此时的编码是反着的，出栈后才是正着的

void fun1(huff v[], int n, char c[], int i) 
{
    stack<char> s;
    int j = v[i].parent;
    while (j)
    {
        if (v[j].lc == i)
            s.push('0');
        else if (v[j].rc == i)
            s.push('1');
        i = j;
        j = v[j].parent;
    }
    int k = 0;
    while (!s.empty())
    {
        c[k++] = s.top();
        s.pop();
    }
    c[k] = '\0';
}

5.翻译哈夫曼编码函数

        首先n只是原先数组中的元素个数，求编码非叶子节点的元素也需要参与运算，所以首先将n的值扩大到(n-1)*2（满二叉树），再循环遍历哈夫曼树中的每一个字符，flag为0代表叶子节点，1代表非叶子节点，当哈夫曼密码为0左转，为1右转，直到到达叶子节点就终止循环，并输出对应字符

void fun2(int n, huff v[], string s) 
{
    n = (n - 1) * 2;
    int i = 0;
    while (i < s.size())
    {
        int cur = n;
        while (v[cur].flag)
        {
            if (s[i] == '0')
            {
                cur = v[cur].lc;
            }
            else if (s[i] == '1')
            {
                cur = v[cur].rc;
            }
            i++;
        
        }
        char a = 'a' + cur;
        cout << a;
    }
}

6.主函数调用

int main()
{
    int n;
    cin >> n;
    huff v[200];
    for (int i = 0; i < n; i++)
    {
        cin >> v[i].weight;
        v[i].parent = v[i].lc = v[i].rc = 0;
        v[i].flag = 0;
    }
    for (int i = n; i < 2 * n - 1; i++)
    {
        v[i].parent = v[i].lc = v[i].rc = 0;
        v[i].flag = 1;
    }
    build_huff(n, v, 2 * n - 1);
    cout << endl;
    string s1;
    string s2;
    cin >> s1 >> s2;
    char c[60];
    for (int i = 0; i < n; i++) 
    {
        fun1(v, n, c, i);
        cout << c << endl;
    }
    cout << endl;
    for (int i = 0; i < s1.size(); i++) 
    {
        int j = s1[i] - 'a';
        fun1(v, n, c, j);
        cout << c;
    }
    cout << endl;
    fun2(n, v, s2);
}