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

15 4 4 3 2

A B C D E

11111

10100001001

00000101100

输出样例1

AAAAA

ABEAD

error

最优二叉树/赫夫曼树

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

构成赫夫曼树的步骤：

思路：

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

cpp 复制代码

#include<bits/stdc++.h>
using namespace std;
struct Node
{
    int weight,left,right,parent;
    string c;
}tree[105];
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++) 
    {
        cin>>tree[i].weight;
        tree[i].parent=0;
        tree[i].left=0;
        tree[i].right=0;
    }
    for(int i=1;i<=n;i++) cin>>tree[i].c;
    int k;
    cin>>k;
    //编码串
    string s[105];
    for(int i=0;i<k;i++) cin>>s[i];
    //要新建n-1个节点
    for(int i=n+1;i<2*n;i++)
    {
        tree[i].parent=0;
        tree[i].weight=0;
        //找两个权值最小的
        for(int j=0;j<2;j++)
        {
            int small=20000,loc=0;
            for(int k=1;k<i;k++)
            {
                if(tree[k].parent==0&&tree[k].weight<small)
                {
                    small=tree[k].weight;
                    loc=k;
                }
            }
            tree[loc].parent=i;
            //默认左子树小右子树大
            (j)?tree[i].right=loc:tree[i].left=loc;
            tree[i].weight+=tree[loc].weight;
        }
    }
    //解码
    for(int i=0;i<k;i++)
    {
        string str=s[i];
        string res="";
        int len=str.size();
        int k=0,cur=2*n-1;
        bool flag=0;
        while(k<len)
        {
            //错误的 无法解码
            if(str[k]!='0'&&str[k]!='1')
            {
                flag=1;
                break;
            }
            //是叶子节点 有值可以参与解码
            if(tree[cur].left==0&&tree[cur].right==0)
            {
                res+=tree[cur].c;
                cur=2*n-1;
                continue;
            }
            if(str[k]=='0')
            {
                if(tree[cur].left==0)
                {
                    flag=1;
                    break;
                }
                cur=tree[cur].left;
                k++;
                if(k==len)
                {
                    if(tree[cur].left==0&&tree[cur].right==0)
                    {
                        res+=tree[cur].c;
                        cur=2*n-1;
                    }
                    else flag=1;
                }
                continue;
            }
            if(str[k]=='1')
            {
                if(tree[cur].right==0)
                {
                    flag=1;
                    break;
                }
                cur=tree[cur].right;
                k++;
                if(k==len)
                {
                    if(tree[cur].left==0&&tree[cur].right==0)
                    {
                        res+=tree[cur].c;
                        cur=2*n-1;
                    }
                    else flag=1;
                }
                continue;
            }
        }
        if(flag)
        {
            cout<<"error"<<endl;
            continue;
        }
        cout<<res<<endl;
    }
    return 0;
}