6:2哈夫曼树问题

最新推荐文章于 2022-07-25 10:49:36 发布
最新推荐文章于 2022-07-25 10:49:36 发布
阅读量124 收藏
点赞数
文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63065527/article/details/124991845
版权

一、代码块

读入数据

Status ReadData(char *source){
    //打开文件读入数据
    ifstream infile;
    infile.open("in.txt");
    cout<<"Reading..."<<endl;
    cout<<"the input file is:"<<endl;
    infile.getline(source,MaxSize);
    cout<<source<<endl;
    infile.close();
    cout<<endl;
    return OK;
}

统计次数

Status WordCount(char *data,NumCount *paraCnt){
    //标识是否已经记录
    int flag;
    int len = strlen(data);
    for(int i = 0;i < len; i++){
        flag = 0;
        for(int j = 0;j < paraCnt->length; j++){
            if(paraCnt->count[j].ch == data[i]){
                //若已有记录，直接++
                ++paraCnt->count[j].cnt;
                flag = 1;
                break;
            }
            
        }
        //没有记录，则新增
        if(!flag){
            paraCnt->count[paraCnt->length].ch = data[i];
            ++paraCnt->count[paraCnt->length].cnt;
            ++paraCnt->length;
        }
    }
    return OK;
}

每个单词出现的对应次数

Status Show(NumCount *paraCnt){
    cout<<"the length is "<<paraCnt->length<<endl;
    for(int i = 0;i < paraCnt->length; i++)
    {
        cout<<"The character "<<paraCnt->count[i].ch<<"  appears  "<<paraCnt->count[i].cnt<<endl;
    }
    cout<<endl;
    return OK;
}

建树

Status CreateHuffmanTree(HuffmanTree &HT,int length,NumCount cntarray){
    if(length <= 1) return ERROR;
    int s1,s2;
    //没有度为1的节点，则总结点是2*叶子节点数-1个
    int m = length*2-1;
    HT = new HTNode[m+1];
    for(int i = 1;i <= m; i++){
        //初始化
        HT[i].parent = 0;
        HT[i].lchild = 0;
        HT[i].rchild = 0;
    }
    
    for(int i = 1;i <= length; i++){
        HT[i].data = cntarray.count[i-1].ch;
        HT[i].weight = cntarray.count[i-1].cnt;
    }
    
    for(int i = length + 1;i <= m; i++){
        //从前面的范围里选择权重最小的两个节点
        select(HT,i-1,&s1,&s2);
        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;
    }
    return OK;
}

选择排序

Status select(HuffmanTree HT,int top,int *s1,int *s2){
    int min = INT_MAX;
    //选择没有双亲的节点中，权重最小的节点
    for(int i = 1;i <= top; i++){
        if(HT[i].weight < min && HT[i].parent == 0){
            min = HT[i].weight;
            *s1 = i;
        }
    }
    
    min = INT_MAX;
    //选择没有双亲的节点中，权重次小的节点
    for(int i = 1;i <= top; i++){
        if(HT[i].weight < min && i != *s1 && HT[i].parent == 0)
        {
            min = HT[i].weight;
            *s2 = i;
        }
    }
    return OK;
}

创建编码

Status CreateHuffmanCode(HuffmanTree HT,HuffmanCode &HC,int length){
    HC = new HCode[length+1];
    //存储编码的临时空间
    char *cd = new char[length];
    //方便之后调用strcpy函数
    cd[length-1] = '\0';
    int c,f,start;
    for(int i = 1;i <= length; i++){
        //start表示编码在临时空间内的起始下标，由于是从叶子节点回溯，所以是从最后开始
        start = length-1;
        c = i;
        f = HT[c].parent;
        while(f != 0){
            //由于是回溯，所以从临时空间的最后往回计
            --start;
            if(HT[f].lchild == c)
                cd[start] = '0';
            else
                cd[start] = '1';
            c = f;
            f = HT[c].parent;
        }
        //最后，实际使用的编码空间大小是length-start
        HC[i].str = new char[length-start];
        HC[i].data = HT[i].data;
        //从实际起始地址开始，拷贝到编码结构中
        strcpy(HC[i].str,&cd[start]);
    }
    delete cd;
}

生成编码文件

Status Encode(char *data,HuffmanCode HC,int length){
    ofstream outfile;
    outfile.open("code.txt");
    //依次读入数据，查找对应的编码，写入编码文件
    for(int i = 0;i < strlen(data); i++){
        for(int j = 1;j <= length;++j){
            if(data[i] == HC[j].data){
                outfile<<HC[j].str;
            }
        }
    }
    outfile.close();
    cout<<"the code txt has been written"<<endl;
    cout<<endl;
    return OK;
}

解码

Status Decode(HuffmanTree HT,int length){
    char codetxt[MaxSize*length];
    ifstream infile;
    infile.open("code.txt");
    infile.getline(codetxt,MaxSize*length);
    infile.close();
    
    ofstream outfile;
       outfile.open("out.txt");
    
    int root = 2*length-1;
    //从根节点开始遍历
    for(int i = 0;i < strlen(codetxt); i++){
        //为0表示向左遍历
        if(codetxt[i] == '0'){
            root = HT[root].lchild;
        }
        //为1表示向右遍历
        else if(codetxt[i] == '1'){
            root = HT[root].rchild;
        }
        if(HT[root].lchild == 0 && HT[root].rchild == 0)
            //如果已经是叶子节点，输出到输出文件中，然后重新回到根节点
        {
            outfile<<HT[root].data;
            root = 2*length-1;
        }
    }
    outfile.close();
    cout<<"the output txt has been written"<<endl;
    cout<<endl;
    return OK;
}

二、全部代码

//
//  main.c
//
//  Created by ABC on 2022/5/26.
//


#include <iostream>
#include <fstream>
#include <string.h>
using namespace std;

//读入文件的上限
#define MaxSize 1024
#define OK 1
#define ERROR 0
typedef int Status;

//统计字符和对应的次数
typedef struct wordcnt{
    char ch;
    int cnt = 0;
}Count;

//统计次数的外部封装
typedef struct NumCount{
    Count count[MaxSize];
    int length = 0;
}NumCount;

//哈夫曼树结构
typedef struct HTree{
    char data;
    int weight;
    int parent,lchild,rchild;
}HTNode,*HuffmanTree;

//编码结构
typedef struct HCode{
    char data;
    char* str;
}*HuffmanCode;


//读入文件
Status ReadData(char *source);
//统计次数
Status WordCount(char *data,NumCount *paraCnt);
//展示次数
Status Show(NumCount *paraCnt);
//创建哈夫曼树
Status CreateHuffmanTree(HuffmanTree &HT,int length,NumCount cntarray);
//选择权重最小的两个节点
Status select(HuffmanTree HT,int top,int *s1,int *s2);
//创建哈夫曼编码
Status CreateHuffmanCode(HuffmanTree HT,HuffmanCode &HC,int length);
//将读入的文件编码，写到txt文件
Status Encode(char *data,HuffmanCode HC,int length);
//读入编码文件，解码
Status Decode(HuffmanTree HT,int length);

int main(int argc, char** argv){
    char data[MaxSize];
    NumCount Cntarray;
    //读入数据
    ReadData(data);
    //统计次数
    WordCount(data,&Cntarray);
    //可以查看每个单词出现的对应次数
    Show(&Cntarray);
    HuffmanTree tree;
    //建树
    CreateHuffmanTree(tree,Cntarray.length,Cntarray);
    HuffmanCode code;
    //创建编码
    CreateHuffmanCode(tree,code,Cntarray.length);
    //生成编码文件
    Encode(data,code,Cntarray.length);
    //解码
    Decode(tree,Cntarray.length);
    cout<<"Please view the generated TXT file to check the result"<<endl;
    return 0;
}

Status ReadData(char *source){
    //打开文件读入数据
    ifstream infile;
    infile.open("in.txt");
    cout<<"Reading..."<<endl;
    cout<<"the input file is:"<<endl;
    infile.getline(source,MaxSize);
    cout<<source<<endl;
    infile.close();
    cout<<endl;
    return OK;
}

Status WordCount(char *data,NumCount *paraCnt){
    //标识是否已经记录
    int flag;
    int len = strlen(data);
    for(int i = 0;i < len; i++){
        flag = 0;
        for(int j = 0;j < paraCnt->length; j++){
            if(paraCnt->count[j].ch == data[i]){
                //若已有记录，直接++
                ++paraCnt->count[j].cnt;
                flag = 1;
                break;
            }
            
        }
        //没有记录，则新增
        if(!flag){
            paraCnt->count[paraCnt->length].ch = data[i];
            ++paraCnt->count[paraCnt->length].cnt;
            ++paraCnt->length;
        }
    }
    return OK;
}

Status Show(NumCount *paraCnt){
    cout<<"the length is "<<paraCnt->length<<endl;
    for(int i = 0;i < paraCnt->length; i++)
    {
        cout<<"The character "<<paraCnt->count[i].ch<<"  appears  "<<paraCnt->count[i].cnt<<endl;
    }
    cout<<endl;
    return OK;
}

Status CreateHuffmanTree(HuffmanTree &HT,int length,NumCount cntarray){
    if(length <= 1) return ERROR;
    int s1,s2;
    //没有度为1的节点，则总结点是2*叶子节点数-1个
    int m = length*2-1;
    HT = new HTNode[m+1];
    for(int i = 1;i <= m; i++){
        //初始化
        HT[i].parent = 0;
        HT[i].lchild = 0;
        HT[i].rchild = 0;
    }
    
    for(int i = 1;i <= length; i++){
        HT[i].data = cntarray.count[i-1].ch;
        HT[i].weight = cntarray.count[i-1].cnt;
    }
    
    for(int i = length + 1;i <= m; i++){
        //从前面的范围里选择权重最小的两个节点
        select(HT,i-1,&s1,&s2);
        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;
    }
    return OK;
}

Status select(HuffmanTree HT,int top,int *s1,int *s2){
    int min = INT_MAX;
    //选择没有双亲的节点中，权重最小的节点
    for(int i = 1;i <= top; i++){
        if(HT[i].weight < min && HT[i].parent == 0){
            min = HT[i].weight;
            *s1 = i;
        }
    }
    
    min = INT_MAX;
    //选择没有双亲的节点中，权重次小的节点
    for(int i = 1;i <= top; i++){
        if(HT[i].weight < min && i != *s1 && HT[i].parent == 0)
        {
            min = HT[i].weight;
            *s2 = i;
        }
    }
    return OK;
}

Status CreateHuffmanCode(HuffmanTree HT,HuffmanCode &HC,int length){
    HC = new HCode[length+1];
    //存储编码的临时空间
    char *cd = new char[length];
    //方便之后调用strcpy函数
    cd[length-1] = '\0';
    int c,f,start;
    for(int i = 1;i <= length; i++){
        //start表示编码在临时空间内的起始下标，由于是从叶子节点回溯，所以是从最后开始
        start = length-1;
        c = i;
        f = HT[c].parent;
        while(f != 0){
            //由于是回溯，所以从临时空间的最后往回计
            --start;
            if(HT[f].lchild == c)
                cd[start] = '0';
            else
                cd[start] = '1';
            c = f;
            f = HT[c].parent;
        }
        //最后，实际使用的编码空间大小是length-start
        HC[i].str = new char[length-start];
        HC[i].data = HT[i].data;
        //从实际起始地址开始，拷贝到编码结构中
        strcpy(HC[i].str,&cd[start]);
    }
    delete cd;
}

Status Encode(char *data,HuffmanCode HC,int length){
    ofstream outfile;
    outfile.open("code.txt");
    //依次读入数据，查找对应的编码，写入编码文件
    for(int i = 0;i < strlen(data); i++){
        for(int j = 1;j <= length;++j){
            if(data[i] == HC[j].data){
                outfile<<HC[j].str;
            }
        }
    }
    outfile.close();
    cout<<"the code txt has been written"<<endl;
    cout<<endl;
    return OK;
}

Status Decode(HuffmanTree HT,int length){
    char codetxt[MaxSize*length];
    ifstream infile;
    infile.open("code.txt");
    infile.getline(codetxt,MaxSize*length);
    infile.close();
    
    ofstream outfile;
       outfile.open("out.txt");
    
    int root = 2*length-1;
    //从根节点开始遍历
    for(int i = 0;i < strlen(codetxt); i++){
        //为0表示向左遍历
        if(codetxt[i] == '0'){
            root = HT[root].lchild;
        }
        //为1表示向右遍历
        else if(codetxt[i] == '1'){
            root = HT[root].rchild;
        }
        if(HT[root].lchild == 0 && HT[root].rchild == 0)
            //如果已经是叶子节点，输出到输出文件中，然后重新回到根节点
        {
            outfile<<HT[root].data;
            root = 2*length-1;
        }
    }
    outfile.close();
    cout<<"the output txt has been written"<<endl;
    cout<<endl;
    return OK;
}

三、小结

构建哈夫曼树的过程

对于给定的有各自权值的 n 个结点，构建哈夫曼树有一个行之有效的办法：

  1. 在 n 个权值中选出两个最小的权值，对应的两个结点组成一个新的二叉树，且新二叉树的根结点的权值为左右孩子权值的和；
  2. 在原有的 n 个权值中删除那两个最小的权值，同时将新的权值加入到 n–2 个权值的行列中，以此类推；
  3. 重复 1 和 2 ，直到所以的结点构建成了一棵二叉树为止，这棵树就是哈夫曼树。
  4. 为了获得传送报文的最短长度，可将每个字符的出现频率作为字符结点的权值赋予该结点上，显然字使用频率越小权值越小，权值越小叶子就越靠下，于是频率小编码长，频率高编码短，这样就保证了此树的最小带权路径长度效果上就是传送报文的最短长度。
明天吃西瓜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
哈夫曼树以及哈夫曼编码
haofight的博客
01-11 1344
1.哈夫曼树 假设有n个权值{w1, w2, …, wn}，试构造一棵含有n个叶子结点的二叉树，每个叶子节点带权威wi，则其中带权路径长度WPL最小的二叉树叫做最优二叉树或者哈夫曼树。 特点：哈夫曼树中没有度为1的结点，故由n0 = n2+1以及m= n0+n1+n2，n1=0可推出m=2*n0-1，即一棵有n个叶子节点的哈夫曼树共有2n-1个节点2.哈夫曼编码 通信传
数据结构 哈夫曼树
12-10
3. **重复步骤2**：每次都将当前树中权值最小的两个节点进行合并，直到只剩下一个节点为止，这个节点就是哈夫曼树的根节点。 4. **构建编码**：从根节点到每个叶节点的路径可以生成该叶节点的哈夫曼编码。通常，...
问题 C: 哈夫曼树
韩江雪de 小屋
02-12 386
1 题目 问题 C: 哈夫曼树 [命题人 : 外部导入] 时间限制 : 1.000 sec 内存限制 : 32 MB 题目描述 哈夫曼树，第一行输入一个数n，表示叶结点的个数。需要用这些叶结点生成哈夫曼树，根据哈夫曼树的概念，这些结点有权值，即weight，题目需要输出所有结点的值与权值的乘积之和。 输入 输入有多组数据。 每组第一行输入一个数n，接着输入n个叶节点（叶节点权值不超过100，2&...
哈夫曼树
weixin_30784945的博客
04-06 218
1.构造哈夫曼树的方法对于已知的一组叶子的权值Ｗ 1 ，Ｗ 2...... ，Ｗ n①首先把 n 个叶子结点看做 n 棵树（仅有一个结点的二叉树），把它们看做一个森林。②在森林中把权值最小和次小的两棵树合并成一棵树，该树根结点的权值是两棵子树权值之和。这时森林中还有 n-1 棵树。③重复第②步直到森林中只有一棵为止，此树就是哈夫曼树。 现给一组 (n=4) 具体的权值: 2 ， 4 ， ...
详细了解哈夫曼树和背包问题
梦想高飞的菜鸟
04-13 2224
写在前面 最近在疯狂复习数据结构和算法，虽然看完了一部完整的视频。但是转眼看看自己手中的《剑指Offer》里面还是不是很清楚。。。而且最近也突然觉得自己知识和别人比起来就是一个渣渣。各种被人家吊打。。。 这两个算法一个（哈夫曼树）是看最近视频动手实践的，一个(背包问题)是前段时间一个面试里面的题目，当时不知道这是一个系类的问题，昨天和大神聊完天之后才明白。所以乘着短暂的热情还在就记录下来先从哈夫曼树
基于C语言实现哈夫曼树.zip
05-10
2. **创建哈夫曼节点**：哈夫曼树的每个节点包含两个部分：字符（如果它是叶子节点）和频率。我们可以定义一个结构体来表示这些节点，例如： ```c typedef struct Node { char data; int freq; struct Node* ...
哈夫曼树与哈夫曼编码介绍.zip
04-18
- 带权路径长度的平衡问题：虽然哈夫曼树是最优的，但在某些特定应用中，平衡的二叉树可能会带来更好的性能。 6. **相关算法**： - 堆排序：哈夫曼树的构建过程中用到了最小堆的思想。 - 贪心算法：哈夫曼树的...
哈夫曼树及编码
awm123453的博客
05-28 1490
文章目录一、哈夫曼树的概念二、相关功能实现三、完整代码四、运行结果 一、哈夫曼树的概念 1、哈夫曼树：假设有m个权值，可以构造一棵含n个叶子结点的二叉树，若该树的带权路径长度达到最小，则称这样的二叉树为哈夫曼树。 2、结点的带权路径长度：根节点到任意结点的路径长度与该节点的权值的乘积 3、路径长度：路径上的分支数目 4、树的带权路径长度：树中所有叶子结点的带权路径长度之和 离根结点越远，权值越小 二、相关功能实现 1、结构体的定义 typedef struct wordcnt{ // 统计字符和对应的
哈夫曼树及哈夫曼编码
qq_43628500的博客
12-02 1031
一、相关概念 叶子结点的权值：对叶子结点赋予的一个有意义的数值量。 二叉树的带权路径长度：设二叉树具有n个带权值的叶子结点，从根结点到各个叶子结点的路径长度与相应叶子结点权值的乘积之和。 记为： ...
【树】哈夫曼树(三)
闲人请进
12-14 299
【树】哈夫曼树(三) Time Limit:1000MS  Memory Limit:65536K Total Submit:51 Accepted:29 Description 根据传送的一串字符出现的频率，设置其相应的哈夫曼编码 Input 一串字符 Output 哈夫曼编码（按照中序遍历输出各个字母和编码，中间用冒号分开） Sample Input
6-2 哈夫曼编码
m0_61049596的博客
06-19 388
函数Select (HuffmanTree HT,int len,int &s1,int &s2)是从1到len中找出parent为0的且权值最小的节点编号赋给s1,s2,（s1的节点编号小于s2），函数void CreatHuffmanTree(HuffmanTree &HT,int n)是构造哈夫曼树，函数void CreatHuffmanCode(HuffmanTree HT,HuffmanCode &HC,int n)计算哈夫曼编码。 其中 是哈夫曼树，是哈夫曼编码，是叶子结点个数。
6.2哈夫曼树编码与解码
m0_65022800的博客
05-29 597
哈夫曼树相关的几个名词 路径：在一棵树中，一个结点到另一个结点之间的通路，称为路径。图 1 中，从根结点到结点 a 之间的通路就是一条路径。 路径长度：在一条路径中，每经过一个结点，路径长度都要加 1 。例如在一棵树中，规定根结点所在层数为1层，那么从根结点到第 i 层结点的路径长度为 i - 1 。图 1 中从根结点到结点 c 的路径长度为 3。 结点的权：给每一个结点赋予一个新的数值，被称为这个结点的权。例如，图 1 中结点 a 的权为 7，结点 b 的权为 5。 结点的带权路径长度：指的是从根结点到
数据结构与算法——哈夫曼树
weixin_44871977的博客
02-22 2373
一、哈夫曼树的定义及构造思想 哈夫曼树定义：满足WPL最小的二叉树，即最优树 WPL(带权路径长度):设二叉树有n个叶结点，每个叶子结点带有权值wk，从根结点到每个叶结点长度为lk，则每个叶结点的WPL = ∑wk*lk 哈夫曼树特点： 1.没有度为1的结点，要么度为2要么度为0，因为每个结点都是由子结点两两合并而来。 2.哈夫曼树的任意非叶结点的左右子树交换后仍是哈夫曼树 3.n个叶结点的哈夫曼...
哈夫曼树和哈夫曼编码
u013345179的博客
08-05 198
#include<string.h> #include<cmath> #include<iostream> #include<cstdio> #include<algorithm> #define ll long long using namespace std; struct hfmtree { int parient,lso...
哈夫曼树（Huffman tree）及哈夫曼编码
cyq6239075的博客
06-13 9778
基本术语 1、路径和路径长度 在一棵树中存在着一个节点序列K1,K2,K3…Kj,使得Ki是Ki+1的双亲，则称此节点序列是从K1~Kj的路径，因为树中每个节点只有一个双亲节点，所以他也是这两个之间的唯一路径，从K1~Kj所经过的分支数称为这两个节点之间的路径长度，他等于路径上的节点数减1. 2、节点权和带权路径度 在许多应用中将树中的节点赋值一个有意义的实数，称此实数为该节点的权，节点的带权路径长度规定为从树根节点到该节点之间的路径长度与该节点权的乘积。 3、树的带权路径长度 树的带权路径长度
【数据结构与算法】-哈夫曼树(Huffman Tree)与哈夫曼编码
热门推荐
闪耀大叔的博客
07-25 4万+
超详细讲解哈夫曼树(Huffman Tree)以及哈夫曼编码的构造原理、方法，并用代码实现。
设计c++程序构造哈夫曼树，要求如下：构造哈夫曼树，能演示构造过程，求解出构造哈夫曼树的带权路径长度，给出哈夫曼编码。
最新发布
06-21
设计C++程序构造哈夫曼树通常涉及以下几个步骤： 1. 定义数据结构：首先，我们需要定义一个结构或类来表示字符及其权重（频率），例如： ```cpp struct HuffmanNode { char data; int weight; HuffmanNode* left...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值