数据结构之哈夫曼树

#include <iostream>
#include <iomanip>
#include <string>
using namespace std;

typedef struct
{
    string name;
    int weight;
    int parent,
        lchild,
        rchild;
    int visited;      //设置visited选项来表示每次查找最小权值后的删除,0代表未删除,1表示删除
}HTNode,*HuffmanTree;

int Min(HuffmanTree ht,int m)
{
    int min;
    for(int i=1;i<=m;i++)      //在没有访问过的节点中选择第一个权值作为最小的权值
    {
        if(ht[i].visited==0)
        {
            min=i;
            break;
        }
    }
    for(int i=1;i<=m;i++)        //将选择的最小权值与其他未访问过的权值做比较求出最小权值
    {                            //在此出错,将i的值赋给min,导致循环给min赋值出错。要在循环外给min赋值
        if(ht[i].visited==0&&ht[min].weight>ht[i].weight)
        {
            min=i;
        }
    }
                                            //输出min,验证是否找到的是最小权值的位置
    ht[min].visited=1;

    return min;
}

int main()
{
    HuffmanTree ht;         //全局变量,定义哈夫曼树
    string *hc;                //全局变量,定义哈夫曼编码
    int  ht1=0,
         hc1=0;
    int choice;
    int m,
        n;
    while(1)
    {
        if(ht1==0&&hc1==0)
        {
            cout <<"1. 建立哈夫曼树"<<endl;
            cout <<"---------------------------------------------------------------------------"<<endl;
        }
        if(ht1==1&&hc1==0)
        {
            cout <<"1. 建立哈夫曼树     2. 哈夫曼树编码"<<endl;
            cout <<"---------------------------------------------------------------------------"<<endl;
        }
        if(ht1==1&&hc1==1)
        {
            cout<<"1.  建立哈夫曼树     2  哈夫曼树编码   3.  编码    4.  译码   5.  结束"<<endl;
            cout <<"---------------------------------------------------------------------------"<<endl;
        }
        cout <<"请输入你的选择:";
        cin>>choice;
        if(choice==1)
        {

            cout <<"请输入点的个数:";
            cin>>n;

            m=2*n-1;
            ht=new HTNode[m+1];
            for(int i=1;i<=m;i++)
            {
                ht[i].lchild=0;
                ht[i].rchild=0;
                ht[i].parent=0;
                ht[i].visited=0;
            }

            cout <<"请输入这几个点的相应的信息和权值:"<<endl;
            for(int i=1;i<=n;i++)
            {
                cin>>ht[i].name;
                cin>>ht[i].weight;
            }

            int    s1,
                s2;
            for(int i=n+1;i<=m;i++)
            {
                s1=Min(ht,i-1);
                s2=Min(ht,i-1);
                               //输出最小权值的位置,验证算法是否正确
                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;
            }

            ht1=1;
            cout <<"哈夫曼树构造成功!"<<endl;
            cout <<endl;
        }
        else if(choice==2)
        {
            string str;
            hc=new string[n+1];
            char *cd;
            cd=new char[n];
            cd[n-1]=‘\0‘;
            int    start,
                f,
                c;
            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;
                }
                    str=cd;
                    hc[i]=str.substr(start);
                }
            delete cd;

            hc1=1;
            cout <<"哈夫曼编码成功!"<<endl;
            cout <<endl;
        }
        else if(choice ==3)
        {
            int result=0;                //用来判断是否找到
            string search;
            cout<<"输入你想要查询的字符:";
            cin>>search;
            for(int i=1;i<=n;i++)
            {
                if(ht[i].name==search)
                {
                    cout <<"查找结果是:"<<hc[i]<<endl;
                    result=1;
                }
            }
            if(result==0)
            {
                cout <<"没有该信息!"<<endl;
            }
            cout <<endl;
        }
        else if(choice ==4)
        {
            int result=0;                    //用来判断是否找到
            string str;
            cout <<"请输入要查询的哈夫曼编码:";
            cin>>str;
            for(int i=1;i<=n;i++)
            {
                if(str==hc[i])
                {
                    cout <<"查找的结果是:"<<ht[i].name<<endl;
                    result=1;
                }
            }
            if(result==0)
            {
                cout <<"查找的编码不存在!"<<endl;
            }
            cout <<endl;
        }
        else if(choice==5)
        {
            cout <<"程序结束!"<<endl;
            break;
        }
        else
        {
            cout <<"无此功能!"<<endl;
        }
    }

    return 0;
}
时间: 2024-10-18 01:44:07

数据结构之哈夫曼树的相关文章

20172303 2018-2019-1《程序设计与数据结构》哈夫曼树编码与解码

20172303 2018-2019-1<程序设计与数据结构>哈夫曼树编码与解码 哈夫曼树简介 定义:给定n个权值作为n个叶子结点,构造一棵二叉树,若带权路径长度达到最小,称这样的二叉树为最优二叉树,也称为哈夫曼树(Huffman Tree).哈夫曼树是带权路径长度最短的树,权值较大的结点离根较近. 带权路径长度(Weighted Path Length of Tree,简记为WPL) 结点的权:在一些应用中,赋予树中结点的一个有某种意义的实数. 结点的带权路径长度:结点到树根之间的路径长度与

数据结构例程——哈夫曼树

本文是数据结构基础系列(6):树和二叉树中第15课时哈夫曼树的例程. #include <stdio.h> #include <string.h> #define N 50 //叶子结点数 #define M 2*N-1 //树中结点总数 //哈夫曼树的节点结构类型 typedef struct { char data; //结点值 double weight; //权重 int parent; //双亲结点 int lchild; //左孩子结点 int rchild; //右孩

【数据结构】赫夫曼树的实现和模拟压缩(C++)

赫夫曼(Huffman)树,由发明它的人物命名,又称最优树,是一类带权路径最短的二叉树,主要用于数据压缩传输. 赫夫曼树的构造过程相对比较简单,要理解赫夫曼数,要先了解赫夫曼编码. 对一组出现频率不同的字符进行01编码,如果设计等长的编码方法,不会出现混淆的方法,根据规定长度的编码进行翻译,有且只有一个字符与之对应.比如设计两位编码的方法,A,B,C,D字符可以用00-11来表示,接收方只要依次取两位编码进行翻译就可以得出原数据,但如果原数据只由n个A组成的,那发出的编码就是2n个0组成,这样的

数据结构_哈夫曼树

基本概念 路径:在一棵树中,从任意一个结点到达另一个结点的通路 路径长度:该路径所需经过的边的个数 带权路径长度:从根结点到达该节点的路径长度再乘以该结点权值的结果 带权路径长度和:树所有的叶子结点的带权路径长度和 哈夫曼树:给定n个带权值结点,以它们为叶子结点构造的一棵带权路径和最小的二叉树 哈夫曼树的求法 将所有结点放入集合 K. 若集合 K 中剩余结点大于 2 个,则取出其中权值最小的两个结点,构造他们同时为某个新节点的左右儿子,该新节点是他们共同的双亲结点,设定它的权值为其两个儿子结点的

数据结构知识点——哈夫曼树

7.哈夫曼树 7.1.哈夫曼树的概述 哈夫曼树,也称最优二叉树,它是n个带权叶子结点构成的所有二叉树中,带权路径长度最小的二叉树. 所谓树的带权路径长度,就是树中所有的叶节点的权值乘上其到根结点的路径长度. 权值越大的结点离根结点越近的二叉树才是最优二叉树. 树的带权路径路径长度(WPL)是从树根到每一结点的路径长度之和,记为WPL=(W1*L1+W2*L2+W3*L3+...+Wn*Ln),N个权值Wi(i=1,2,...n)构成一棵有N个叶结点的二叉树,相应的叶结点的路径长度为Li(i=1,

数据结构之哈夫曼树(java实现)-(五)

所谓哈夫曼树就是要求最小加权路径长度,这是什么意思呢?简而言之,就是要所有的节点对应的路径长度(高度-1)乘以该节点的权值,然后保证这些结果之和最小. 哈夫曼树最常用的应用就是解决编码问题.一般我们用的ASCII是固定长度的编码,对于那些常用的字符,使用很长的长度就显得略为浪费空间了. 下面以一个实例来构建一颗哈夫曼编码树. 设字符集S={A,B,C,D,E,F},字符出现的频率W={2,3,5,7,9,12},对字符集进行哈夫曼编码 (1)以频率为树的节点值,构建6个树节点,保存在一个数据集合

基础数据结构-二叉树-赫夫曼树的解码(详解)

本篇是上一篇赫夫曼树构建与编码的后续,稍微详细讲一下解码的算法. Huffman解码算法流程: 1.定义指针p指向赫夫曼树结点,实际是记录结点数组的下标: 2.定义指针i指向编码串,定义ch逐个取编码串的字符: 3.初始化:读入编码串,设置p指向根结点,i为0: 4.执行以下循环: a)取编码串的第i个字符放入ch: b)如果ch是字符0,表示往左孩子移动,则p跳转到右孩子: c)如果ch是字符1,表示往右孩子移动,则p跳转到右孩子: d)如果ch非0非1,表示编码串有错误,输出error表示解

【数据结构】哈夫曼树实现编码译码

根据一段字符串中字符的个数 作为该字符的权值生成哈夫曼树. 然后根据生成的哈夫曼编码,对任意字符串实现编码,对任意二进制串实现译码. 程序运行结果: 1.程序主界面: 2.根据字符串 创建哈夫曼树及编码: 3.生成的编码表如下: 4.根据生成的哈夫曼编码对字符串编码: 5.生成的编码保存在文件中: 6.对二进制串译码: 结果: 代码: 哈夫曼树的生成和编码的常见,以及编码和译码函数 //_HuffmanTree_H #ifndef _HuffmanTree_H #define _HuffmanT

数据结构 - 赫夫曼树及其应用

赫夫曼树及其应用 赫夫曼(Huffman)树又称最优树,是一类带权路径长度最短的树,有着广泛的应用. 1 基本概念 ① 结点路径:从树中一个结点到另一个结点的之间的分支构成这两个结点之间的路径. ② 路径长度:结点路径上的分支数目称为路径长度. ③ 树的路径长度:从树根到每一个结点的路径长度之和. ④ 结点的带权路径长度:从树的根结点到该结点的的路径长度与结点的权(值)的乘积. 权(值):各种开销.代价.频度等的抽象称呼. ⑤ 树的带权路径长度:树中所有叶子结点的带权路径长度之和,记做: WPL