【数据结构】赫夫曼树与赫夫曼编码（可执行完整代码）

最新推荐文章于 2022-04-24 13:16:41 发布
最新推荐文章于 2022-04-24 13:16:41 发布
阅读量977 收藏 16
点赞数 9
分类专栏： 数据结构与算法分析 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42848174/article/details/106259586
版权

赫夫曼编码对文件进行压缩与解密

理论

赫夫曼树

先有赫夫曼树，才有赫夫曼编码。所以，首先简单介绍一下什么是赫夫曼树。

假设一共五个叶子节点，分别是2、3、5、7、8

那么生成的赫夫曼树就是下面这样：
赫夫曼树

  1. 赫夫曼树也叫最优二叉树，它的每一个结点具有一个权值。权值越大的结点离根节点越近，这样子从根节点到每一个叶子结点的所有带权路径的和（WPL）最小。

  2. 假设叶子结点为 n， 则总结点数 = 2*n-1

    因为：
    叶子节点的度为 0，其他节点的度为2。
    有：
    （总结点数 - 叶子节点数）x 2 = 边数
    又因为：
    总结点数 - 1 = 边数
    综上：
    总结点数 = 2 x 叶子节点数 - 1

  3. 按照叶子节点的数量和权值，以一种特定的规则，自下而上地建立一颗赫夫曼树。

  4. 可任意交换赫夫曼树中兄弟结点的位置，带权路径和（WPL）不变。

  5. 代码实现(具体见附加代码中的相关构造函数)：

  • 采用顺序结构来存储，也就是结构数组。
  • 数组大小为二倍的结点数减一（2*n-1）， 每个元素表示一个结点。
  • 先录入 n 个叶子节点，再每次找到权值最小的两个无双亲的结点进行合并。
  • 合并成的新结点加入到数组后面，直到生成2*n-1个元素

赫夫曼编码

  1. 对于字符串“ABACCDA”
  2. 以字符出现频率作为权值，则：
  3. A: 3， B: 1，C: 2， D：1
  4. 建立赫夫曼树：
    在这里插入图片描述
  5. 如图， 若从根结点，到叶子结点。每次向左为0，向右为1。如此每一个叶子节点都对应一个独一无二的编码，叫做赫夫曼编码。
  6. A: 1
    B: 000
    C: 01
    D: 001
  7. 原字符串就变成了
    1 000 1 01 01 001 1
  8. 代码实现（详情见附加代码）：

对于每一个叶子节点，从叶节点开始，顺着结构中 parent 的下标，遍历到根节点。
期间如果当前节点是当前节点父节点的左儿子，字符串添加一个0
否则添加一个1
遍历到根节点时，将形成的字符串逆置strrev。
对于存储得到的字符串，可以用指针数组来存。char *huffmanCode[n];

应用

应用源码

1. 先在桌面建立一个 txt 文本，文件里面阔以随便写一段文章（我这不支持对中文字符加密，你们阔以自行拓展）。
2. 然后运行下面这段又臭又长的代码，输入路径文本所在路径，然后按照提示进行操作就行了。
3. 最终相同路径下会产生一个加密文件和一个解密后的文件。 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <windows.h>
#include <limits.h>
#define MAX 1e4

char *HC[150];//指针数组，哈夫曼编码，按顺序对应哈夫曼树。
int input_Data[150], number; //字符串的频率, 种类数
char path[100]; //路径

typedef struct Node
{
    char value;
    int weight;
    int lchild;
    int rchild;
    int parent;
}HTNode, *HuffmanTree;
HuffmanTree   HT = NULL;

void   work(void);              //输出交互界面
void   Coding(void);            //对文件进行编码
HuffmanTree   build_Huffman_Tree(void);//建立哈夫曼树
void   Huffman_Coding(void);    //建立哈夫曼编码HC
void   output_HC(void);         //打印编码表
void   Encrypt(void);           //生成加密文件
void   Decode(void);            //生成解密文件23
char*  creat_Path(char *name);  //生成路径名称
int get_Min(HuffmanTree ht, int k);//得到前k个无父节点的最小权重节点
int found_Char(char ch);        //查找输入字符所对应的HC下标
int Check(void);                //将解密文件与源文件比较
void Continue(void);            //输出是否继续操作对话框

int
main()
{
    printf("---------------欢迎进入文件编码与解码程序---------------\n");
    printf("                                    ----by 方宁 20.05.09\n\n");
    printf("请输入你所需要进行操作的文件路径：\n");

    scanf("%s", path);      //主函数中获取一次操作路径
    work();
    return 0;
}

//清屏，和重新调用主菜单
void
Continue(void)
{
    char    str[5];
    printf("是否继续进行操作?(yes/no)\n");
    scanf("%s", str);
    if(strcmp(str, "yes") == 0){
        system("cls");
        work();
    }
    else{
        printf("欢迎您的使用，再见\n");
        Sleep(1000);
    }
}

//对指定文件进行哈夫曼编码
void
Coding(void)
{
    FILE *fp = NULL;
    char ch;
    printf("\n文件读取中...\n");
    fp = fopen( path, "r" );
    if(fp == NULL){
        printf("文件打开失败\n");
        Sleep(1000);
        exit(-1);
    }
    //读取文件字符，计算权值
    while( (ch = fgetc(fp)) != EOF){

        if(input_Data[ch - '\0'] == 0)
            number++;
        input_Data[ch - '\0']++;
    }
    fclose( fp );
    printf("文件读取成功！\n\n");

    printf("正在建立哈夫曼树...\n\n");
    HT = build_Huffman_Tree();
    printf("哈夫曼树建立成功！\n\n");

    printf("进行哈夫曼编码...\n\n");
    Huffman_Coding();
    printf("进行哈夫曼编码成功！\n\n");

    printf("---------编码表---------\n");
    output_HC();

    printf("对文件进行加密...\n\n");
    Encrypt();
    printf("文件加密成功！\n\n");
}

//由叶子节点(n)建立哈夫曼树,结点数：2*n-1
HuffmanTree
build_Huffman_Tree(void)
{
    int   i  ,  k = 0;
    int   total = 2*number - 1;
    int   min1, min2;
    HuffmanTree ht = NULL;
    ht = (HuffmanTree)malloc( 2*number*sizeof(HTNode) );
    if(ht == NULL){
        printf("ht malloc faild\n");
        Sleep(1000);
        exit(-1);
    }
    for(i = 0; i < total; i++){
        ht[i].parent = -1;
        ht[i].lchild = -1;
        ht[i].rchild = -1;
        ht[i].weight = 0;
    }
    for(i = 0; i < 150; i++){
        if(input_Data[i] > 0){
            ht[k].value = i + '\0';
            ht[k++].weight = input_Data[i];
        }
    }

    for(; k < total; k++)
    {
        min1 = get_Min(ht, k);
        min2 = get_Min(ht, k);
        ht[min1].parent = k;
        ht[min2].parent = k;
        ht[k].weight = ht[min1].weight + ht[min2].weight;
        ht[k].lchild = min1;
        ht[k].rchild = min2;
    }
    return ht;
}

int
get_Min(HuffmanTree ht,  int k)
{
    int i = 0, min;
    while( ht[i].parent != -1)
        i++;
    min = i;
    i++;
    for(; i < k; i++)
    {
        if( ht[i].parent == -1 && ht[i].weight < ht[min].weight )
            min = i;
    }
    ht[min].parent = -2;
    return min;
}

//建立哈夫曼编码，存储在指针数组中
void
Huffman_Coding(void)
{
    char   str[number];
    int    p , i;
    int father;
    int current;
    //由叶子节点到根节点，产生路径串的逆strrev
    for(i = 0; i < number; i++)
    {
        father = HT[i].parent;
        current = i;
        p = 0;

        while( HT[current].parent != -1 ){
            if( HT[father].lchild == current )
                str[p++] = '0';
            else
                str[p++] = '1';
            current = father;
            father = HT[current].parent;
        }
        str[p] = '\0';
        strrev(str);
        HC[i] = NULL;
        HC[i] = (char *)malloc( (strlen(str)+1)*sizeof(char) );
        if(HC[i] == NULL){
            printf("HC[%d] malloc faild\n", i);
            Sleep(1000);
            exit(-1);
        }
        //HC[0] = '\0';
        strcpy(HC[i], str);
    }
}

void
output_HC(void)
{
    int i;

    for(i = 0; i < number; i++)
        printf("'%c'： %s\n", HT[i].value, HC[i]);

    /**调试打印哈夫曼树，无误
    for(i = 0; i < number*2-1; i++){
        if(i < number)
            printf("'%c': %s\n", HT[i].value, HC[i]);
        printf("%d. %d %d %d %d\n",i, HT[i].parent, HT[i].lchild, HT[i].rchild, HT[i].weight);
    }
    **/
    putchar('\n');
}

//建立加密文件夹，将字符转化成哈夫曼码，写入文件
void
Encrypt(void)
{
    char ch;
    FILE *fp1 = NULL, *fp2 = NULL; //加密文件，原文件

    fp1 = fopen( creat_Path("加密.txt"), "w+" );
    if(fp1 == NULL){
        printf("加密文件打开失败\n");
        Sleep(1000);
        exit(-1);
    }

    fp2 = fopen( path, "r");
    if(fp2 == NULL){
        printf("原文件打开失败\n");
        Sleep(1000);
        exit(-1);
    }

    while( (ch = fgetc(fp2)) != EOF ){
        int i = found_Char(ch);
        if(i != -1)
            fputs(HC[i] , fp1);
        else
            fputc('#', fp1);    //如果有找不到的字符，用输出#表示
    }
    fclose(fp1);
    fclose(fp2);
}

int found_Char(char ch)
{
    int i;
    for(i = 0; i < number; i++){
        if(HT[i].value == ch)
            return i;
    }
    return -1;
}

//从根节点遍历到叶子节点作为一个字符解码结束
void
Decode(void)
{
    FILE *fp1, *fp2;
    int   root = 2*number - 2;
    int   current = root;
    char ch;
    printf("正在进行解码...\n");
    fp1 = fopen( creat_Path("解密.txt"), "w+" );
    if(fp1 == NULL){
        printf("解密文件打开失败\n");
        Sleep(1000);
        exit(-1);
    }

    fp2 = fopen( creat_Path("加密.txt"), "r" );
    if(fp2 == NULL){
        printf("加密文件打开失败\n");
        Sleep(1000);
        exit(-1);
    }

    while( (ch = fgetc(fp2)) != EOF )
    {
        if(ch == '0')
            current = HT[current].lchild;
        else if(ch == '1')
            current = HT[current].rchild;
        else
            continue;
        if(current < number){
            fputc(HT[current].value, fp1);
            current = root;
        }
    }

    fclose(fp1);
    fclose(fp2);
    printf("解码成功\n");
    Sleep(1000);
}

//选项三，对比源文件和解密后的文件是否一致
int
Check(void)
{
    FILE *fp_source, *fp_decode;
    char ch1, ch2;
    fp_source = fopen(path, "r");
    fp_decode = fopen(creat_Path("解密"), "r");
    while( (ch1 = fgetc(fp_decode)) != EOF ){
        ch2 = fgetc(fp_source);
        if(ch1 != ch2){
            printf("解密字符 '%c' 与原字符 '%c' 匹配错误\n", ch1, ch2);
            return 0;
        }
    }
    return 1;
    fclose(fp_source);
    fclose(fp_decode);
}

///操作主界面
void
work(void)
{
    char   ch;
    printf("\n请输入你要进行的操作：\n");
    printf("1. 编码      2. 解码     3. 校验\n");
    getchar();
    scanf("%c", &ch);
    switch(ch)
    {
        case '1':
            Coding();
            break;
        case '2':
            Decode();
            break;
        case '3':
            printf("正在进行校验...\n");
            if(Check())
                printf("解密文件与源文件一致\n");
            else
                printf("解密文件与源文件不一致\n");
            Sleep(1000);
            break;
        default:
            printf("输入有误,程序结束\n");
            Sleep(1000);
            return;
    }
    Continue();
}

//修改用户输入的路径，产生新的路径。
char*
creat_Path(char *name)
{
    char *path2 = NULL;
    int p;
    path2 = (char *)malloc( 100*sizeof(char) );
    path2[0] = '\0';
    strcat(path2, path);

    p = strlen(path2) - 1;

    while( path2[p-1] != 92 )
        p--;
    path2[p] = '\0';

    strcat(path2, name);
    return path2;
}

运行结果截图

  1. 生成的加密文件内容，与源文件进行对比。

对文件进行赫夫曼编码图

  1. 对加密后的01文件，进行解密后，再与原文对比：

解码文件

方宁fangning
关注
  • 9
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
PTA 数据结构 哈夫曼树与哈夫曼编码
借用一下服务器
12-13 3325
文章目录题目描述输入格式输出格式样例一点说明想法实现 题目描述 题目背景:介绍什么是哈夫曼树和哈夫曼编码, 不影响做题 哈夫曼树(Huffman Tree)又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。树的路径长度是从树根到每一结点的路径长度之和，记为WPL=（W1*L1+W2*L2+W3*L3+...+Wn*Ln），N个权值Wi（i=1,2,...n）构成一棵有N个叶结点的
（数据结构） 哈夫曼树的编码和解码简单的实现
weixin_45944348的博客
07-04 2914
输入一段英文原文，构造哈夫曼树，生成对应的编码表，输出原文对应的编码，或者是根据已经生成的编码表，输入一段二进制数编码，得到对应的字符原文。 #include<stdio.h> #include<iostream> #include<conio.h> #include<string.h> #include<stdlib.h> using namespace std; //哈夫曼树的存储表示 typedef struct{ int weight
哈夫曼树和哈夫曼编码
Forest_GMY的博客
04-17 1341
概念 哈夫曼树，也叫最优二叉树。在含有给定的n个带权叶子结点的二叉树中，WPL最小的树。其中，结点的权指的是某种特定含义的数值；带权路径长度值根到结点的路径长度乘以结点权值；树的带权路径长度(WPL)是指树中所有叶子结点的带权路径长度之和。 构造 根据哈夫曼算法，叙述如下： 1.根据给定的n个权值{w1,w2,…,wn}构成的n棵二叉树集合F={T1,T2,…,Tn}，其中每棵二叉树Ti中只有一个带权为wi的根结点，其左右子树均为空。 2.在F中选取两棵根结点权值最小的树作为左右子树构造一棵新的二叉树，且置
哈夫曼编码构造最优生成树c语言,[C++] 数据结构之哈夫曼树(最优满二叉树) / 哈夫曼编码...
weixin_35742852的博客
05-23 510
一 哈夫曼树1.1 基本概念算法思想贪心算法(以局部最优，谋求全局最优)示例【树论：最优(二叉)数=带权路径最短的树】【图论：单源最短路径=从某一结点出发至其他结点的带权路径之和最小 / 多源最短路径=某一对结点之间的带权路径之和最小】定义哈夫曼树 = 最优((满)二叉)树 = 带权路径之和最短的树哈夫曼树所产生的哈夫曼编码 = (最优)前缀编码1.2 算法描述/构造过程1.3 算法实现1>...
哈夫曼树及哈夫曼编码详解【完整版代码】
热门推荐
wardseptember的博客
06-17 11万+
Huffman Tree简介&amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;amp;nbsp; 赫夫曼树（Huffman Tree），又称最优二叉树，是一类带权路径长度最短的树。假设有n个权值{w1,w2,…,wn}，如果构造一棵有n个叶子节点的二叉树，而这n个叶子节点的权值是{w1,w2,…,wn}，则所构造出的带权路径长度最小的二叉树就被称为赫夫曼树。&amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;a
数据结构——赫夫曼树的实例代码
08-09
在提供的文件中，“MyHuffmanCode.cpp”很可能是实现以上过程的源代码，而“MyHuffmanCode.exe”是编译后的可执行程序，用于读取输入数据并进行赫夫曼编码。"BasicCodeText.txt"和"BasicRefer.txt"可能分别包含了待...
赫夫曼编码译码器
11-13
文件列表中的"赫夫曼编码译码器.exe"很可能是这个程序的可执行文件，用户可以直接运行进行编码或解码操作。另一个同名但无扩展名的文件可能是程序的源代码或者相关的配置文件，用于查看或编辑程序的实现细节。 在...
基于C/C++的数据结构ADT演示系统
03-19
**基于C/C++的数据结构ADT演示系统** 在计算机科学中，抽象数据类型...通过这个系统，开发者可以更好地掌握数据结构的精髓，这对于编写高效、可维护的代码至关重要。无论是初学者还是经验丰富的程序员，都能从中受益。
数据结构期末复习资料111
最新发布
01-09
赫夫曼编码是基于赫夫曼树的编码方式，能有效减少存储空间。 5. **排序算法**：包括直接插入排序、希尔排序、折半插入排序、冒泡排序、快速排序、简单选择排序、归并排序等。理解这些排序算法的工作原理和它们的...
基于C/C++的数据结构ADT演示系统（全操作）
03-20
数据结构是计算机科学中的核心概念，它涉及到如何有效地组织和管理数据，以便高效地执行各种操作。抽象数据类型（ADT）是数据结构的一种高级表示，它定义了数据的逻辑结构以及与这些数据相关的操作。在C/C++编程中，...
【C++】根据输入的字符串生成哈夫曼树, 并进行哈夫曼编码和解码
01-03
/********************************************************************** * Description : create huffmanTree and huffmanCode by input string * and decode a 0、1 sequence by huffmanCode * Author : wandugu * DATE : 2020-05-02 ************************************
数据结构-哈夫曼编码例题
ZZULI_星.夜
05-03 4万+
致读者： 博主是一名数据科学与大数据专业大二的学生，真正的一个互联网萌新，写博客一方面是为了记录自己的学习历程，一方面是希望能够帮助到很多和自己一样处于困惑的读者。由于水平有限，博客中难免会有一些错误，有纰漏之处恳请各位大佬不吝赐教！之后会写大数据专业的文章哦。尽管当前水平可能不及各位大佬，但我会尽我自己所能，做到最好☺。——天地有正气，杂然赋流形。下则为河岳，上则为日星。 假设用于通信的电...
赫夫曼编码树（图解+完整代码）
weixin_54186646的博客
04-24 1万+
赫夫曼树的构建与赫夫曼编码的图解剖析与完整代码，包含定长编码、变长编码、前缀码
构建哈夫曼树和编码输出
guangod的博客
09-20 3088
c++代码实现: // MyTest.cpp : 定义控制台应用程序的入口点。 /*哈夫曼构建 思想是弄成一个结构体数组,结构体数据本身就具备了表的特征 */ #include "stdafx.h" #include <algorithm> #include <cstring> #include <cstdlib> #include <iostrea...
Huffman树（哈夫曼树）、哈夫曼编码、最优前缀码、前缀码
THEAQING
03-14 1万+
目录 基本概念： 哈夫曼树的构造 哈夫曼树的应用——哈夫曼编码 附：前缀码 基本概念： 需要了解的一些基概念： 路径：结点序列满足是的双亲。 路径长度：路径的分支数。L=k-1 扩充二叉树：在一般二叉树中，将原来的每个空指针都指向一个特殊的结点——外结点，这样的二叉树称为扩充二叉树。 内结点——原来二叉树中的结点。 结点个数S=内结点个数+1 树的内路径长度：从根结点到各个...
哈夫曼树与哈夫曼编码
Y_23k_bug的专栏
07-26 5854
在一般的数据结构的书中，树的那章后面，著者一般都会介绍一下哈夫曼(HUFFMAN) 树和哈夫曼编码。哈夫曼编码是哈夫曼树的一个应用。哈夫曼编码应用广泛，如 JPEG中就应用了哈夫曼编码。 首先介绍什么是哈夫曼树。哈夫曼树又称最优二叉树， 是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点 的权值乘上其到根结点的 路径长度（若根结点为0层，叶结点到根结
哈夫曼树 代码实现
分享不仅为了他人，同时也为了自己
10-09 2444
什么是哈夫曼树。哈夫曼树又称最优二叉树， 是一种带权路径最短的二叉树。所谓树的路径长度，就是树中所有的叶结点 的权值乘上其到根结点的 路径长度（若根结点为0层，叶结点到根结点的路径长度 为叶结点的层数）。树的带权路径长度记为W= (W1*L1+W2*L2+W3*L3+...+Wn*Ln) ，N个权值Wi(i=1,2,...n)构成一棵有N个叶结点的二叉树，相应的叶结点的路径
赫夫曼树的构造与存储以及赫夫曼编码与解码算法
FoggyProgrammer的博客
12-21 1362
程序要求 构建一个赫夫曼树编/译码器。根据提供的字符集和统计结果，按赫夫曼算法构造赫夫曼树，根据赫夫曼树得到每个赫夫曼编码并输出结果，能够将一个字符串转化为对应的赫夫曼编码串，能够将赫夫曼编码字符串译码。 数据结构题集（C语言版）清华大学出版社 p149 5.2 程序代码 #include <stdio.h> #include <malloc.h> #include &...
哈夫曼树 构造，编码 完整代码
m0_61628700的博客
04-04 2715
Haffman Tree 构造方法： 1.初始化每个叶子结点都是一棵树。 2.找最小权值的两棵树。 3.合并两树，生成新结点。 编码： 1.往左为1，右为0. 2.不等长编码。 #include<stdio.h> #include<malloc.h> #include<stdlib.h> ​ #define MaxN 100 //最大结点个数 #define Maxbit 255 //最大编码值 #define MaxValue 9999 //最大权
数据结构专业课程设计哈夫曼编码.doc
12-06
数据结构专业课程设计哈夫曼编码.doc是一份关于数据结构和算法课程设计的文档，目的是通过该设计任务书来进行学术研究和实践，进一步巩固对数据结构和算法的理论知识，并通过实现一个赫夫曼编码/译码器来加深对相关...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值