DS二叉树--赫夫曼树解码/最优二叉树【数据结构】

DS二叉树–赫夫曼树解码

题目描述
已知赫夫曼编码算法和程序，在此基础上进行赫夫曼解码

可以增加一个函数：int Decode(const string codestr, char txtstr[]);//输入编码串codestr，输出解码串txtstr

该方法如果解码成功则返回1，解码失败则返回-1，本程序增加宏定义ok表示1，error表示-1

赫夫曼解码算法如下：

定义指针p指向赫夫曼树结点，指针i指向编码串，定义ch逐个读取编码串的字符

初始操作包括读入编码串str，设置p指向根结点，i为0表示指向串首，执行以下循环：

1）取编码串的第i个字符放入ch

2）如果ch是字符0，则p跳转到左孩子；如果ch是字符1，则p跳转到右孩子；如果ch非0非1，表示编码串有错误，报错退出

3）如果p指的结点是叶子，输出解码字符，p跳回根结点，i++，跳步骤1

4）如果p指的结点不是叶子且i未到编码串末尾，i++，跳步骤1

5）如果p指的结点不是叶子且i到达编码串末尾，报错退出

当i到达编码串末尾，解码结束。

输入
第一行先输入n，表示有n个叶子
第二行输入n个权值，权值全是小于1万的正整数
第三行输入n个字母，表示与权值对应的字符
第四行输入k，表示要输入k个编码串
第五行起输入k个编码串

输出
每行输出解码后的字符串，如果解码失败直接输出字符串“error”，不要输出部分解码结果

输入样例1
5
15 4 4 3 2
A B C D E
3
11111
10100001001
00000101100

输出样例1
AAAAA
ABEAD
error

最优二叉树/赫夫曼树

最优二叉树：也称哈夫曼树或者霍夫曼树、赫夫曼树，给定n个权值作为n个叶子结点(每个叶子结点会有权值)，构造一颗二叉树，若该树的带权路径长度(wpl)达到最小
赫夫曼树：带权路径长度最短的树，权值较大的结点离根较进。（值都在叶子结点上）
构成赫夫曼树的步骤：

思路：

1. 从小到大进行排序, 将每一个数据，每个数据都是一个节点 ， 每个节点可以看成是一颗最简单的二叉树
2. 取出根节点权值最小的两颗二叉树
3. 组成一颗新的二叉树, 该新的二叉树的根节点的权值是前面两颗二叉树根节点权值的和
4. 再将这颗新的二叉树，以根节点的权值大小 再次排序， 不断重复 1-2-3-4 的步骤，直到数列中，所有的数据都被处理，就得到一颗赫夫曼树

#include<bits/stdc++.h>
using namespace std;
//表示节点
struct node
{
    int parent=0,left=0,right=0,weight=0;
    string ch;
}arr[205];
int main()
{
    int n;
    cin>>n;
    //从1开始
    for(int i=1;i<=n;i++) cin>>arr[i].weight;
    for(int i=1;i<=n;i++) cin>>arr[i].ch;
    //新建n-1个节点
    for(int i=n+1;i<2*n;i++)
    {
        //找两个最小的
        for(int j=0;j<2;j++)
        {
            int small=99999999;
            int loc;
            for(int k=1;k<i;k++)
            {
                if(!arr[k].parent&&arr[k].weight<small)
                {
                    small=arr[k].weight;
                    loc=k;
                }
            }
            arr[loc].parent=i;
            (j)?arr[i].right=loc:arr[i].left=loc;
            arr[i].weight+=arr[loc].weight;
        }
    }
    int k;
    cin>>k;
    for(int i=0;i<k;i++)
    {
        string s;
        cin>>s;
        //头节点
        int cnt=2*n-1;
        string res="";
        bool flag=0;
        for(int j=0;j<s.size();j++)
        {
            //是叶子节点，有解码内容
            if(!arr[cnt].left&&!arr[cnt].right)
            {
                res=res+arr[cnt].ch;
                cnt=2*n-1;
            }
            if(s[j]=='1')
            {
                if(!arr[cnt].right) 
                {
                    flag=1;
                    break;
                }
                cnt=arr[cnt].right;
                //防止j无法进入下一个循环而无法更新最新的值
                if(j==s.size()-1)
                {
                    if(!arr[cnt].left&&!arr[cnt].right)
                    {
                        res=res+arr[cnt].ch;
                        cnt=2*n-1;
                    }
                    //如果到了最后一个码却还没有叶子节点对应则出错
                    else flag=1;
                }
                continue;
            }
            if(s[j]=='0')
            {
                if(!arr[cnt].left)
                {
                    flag=1;
                    break;
                }
                cnt=arr[cnt].left;
                //防止j无法进入下一个循环而无法更新最新的值
                if(j==s.size()-1)
                {
                    if(!arr[cnt].left&&!arr[cnt].right)
                    {
                        res=res+arr[cnt].ch;
                        cnt=2*n-1;
                    }
                    //如果到了最后一个码却还没有叶子节点对应则出错
                    else flag=1;
                }
                continue;
            }
            //说明码既不是0也不是1 出错
            flag=1;
            break;
        }
        if(flag) cout<<"error"<<endl;
        else cout<<res<<endl;
    }
    return 0;
}