Huffman编码、Huffman树(源码)

于 2024-03-24 15:02:27 发布
阅读量793 收藏 7
点赞数 25
文章标签： 算法 数据结构 c++ c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62803088/article/details/126913672
版权

Huffman树：

        给定N个权值作为N个叶子节点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。

        在计算机数据处理中，哈夫曼编码使用变长编码表对源符号（如文件中的一个字母）进行编码，其中变长编码表是通过一种评估来源符号出现机率的方法得到的，出现机率高的字母使用较短的编码，反之出现机率低的则使用较长的编码，这便使编码之后的字符串的平均长度、期望值降低，从而达到无损压缩数据的目的。

具体的逻辑在这里就不多说了，网上一大堆...这里主要说一说我的代码思路。

结构体定义：

        { *l, data, *r}: 该结构体的data记录字符，l 指向左节点，r 指向右节点，在建立Huffman树的时候要用到。       

        {*Hnode, cnt, *next}: 该结构体的 Hnode 指向 {*l, data, *r} 结构体，cnt 记录字符的权重，*next 指向 {*Hnode, cnt, *next} 结构体，插入链表和排序的时候需要用到。

        {size ,*first}: 该结构体的size记录链表的长度，*first 是一个指向结构体HuffTree的指针。

代码思路:

        输入一行字符串，记录一下每个字符出现的次数也就是这个字符的权重，然后用链表将它们按顺序连接 (如下图)。

假设输入的字符串为：abcda

        每次取出最小的两个结点，小的放左边，大的放右边，构建一个新的结点，这个新结点的权重是刚才取出来的两个结点权重的和。

        再将这个新结点插入链表，依旧按顺序排放，表头的 size--。

         如此往复，最终链表里只剩下一个结点，此时这个结点就是Huffman树的根节点。

        遍历这棵树，拿到每个字符的编码。注：使用栈记录走过的路。

        例：想要获取字符 a 的编码，从根节点往左走 (往左走记为0，往右走记为1)，则把0压入栈，然后判断该结点有没有左右孩子 (通过观察发现，存入字符的点都没有左右孩子)，如果有，那栈内存放的路径就是该字符所对应的编码。a: 0, b: 110, c: 111, d: 10。

        所以字符串 abcda 对应的编码为: 0110111100

        遍历Huffman编码，0为往左走，1为往右走，找到字符后存入数组，返回根结点，继续找下一个字符，直到遍历完所有的编码，此时数组内存放的就是解码后的字符串。

具体实现:

  statement.h        // 自定义一个头文件

#ifndef _INIT_STATEMENT_H
#define _INIT_STATEMENT_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_SIZE 256

typedef char ElemType;
typedef int Count;

// 霍夫曼树结点
typedef struct HuffNode
{
    ElemType data;
    struct HuffTree *left, *right;
} HuffNode;

// 霍夫曼树
typedef struct HuffTree
{
    HuffNode *Hnode;
    Count cnt;
    struct HuffTree *next;
} HuffTree;

// 链表
typedef struct LinkList
{
    int size;
    HuffTree *first;
} LinkList;

typedef struct Stack
{
    ElemType *base, *top;
    int STACK_SIZE;
} Stack;

ElemType code[MAX_SIZE];
ElemType resStr[MAX_SIZE];
ElemType codeTable[MAX_SIZE][MAX_SIZE];

// HuffTree.c
HuffTree *getPriority(ElemType *str);
HuffTree *LinkNode(ElemType *array);
void sortNode(LinkList *list, HuffNode *newNode, int cnt);
HuffTree *createHuffTree(LinkList *list);
void insertNode(LinkList *list, HuffTree *cnn);

// Encode.c
ElemType *encode(HuffTree *root, ElemType *str);
void createStack(Stack *stack);
void recurse(HuffTree *root, Stack *stack);
ElemType *splice(ElemType *code, ElemType *str);
void destoryStack(Stack *stack);

// Decode.c
ElemType *decode(HuffTree *root, ElemType *code);
void destroyHuffTree(HuffTree *root);

#endif

mainPort.c

#include "statement.h"

int main(void)
{
    char s[100] = "How are you?";           // 在这输入想要编码的字符串(数字、字母或符号)
    printf("string: %s\n", s);
    HuffTree *tree =  BuildHuffmanTree(s);
    ElemType *code = encode(tree, s);
    printf("encode: %s\n", code);
    ElemType *res = decode(tree, code);
    printf("decode: %s\n", res);
    return 0;
}

HuffTree.c

#include "statement.h"

// 计数
HuffTree *BuildHuffmanTree(ElemType *str)
{
    ElemType array[MAX_SIZE] = {0};
    for (int i = 0; i < strlen(str); i++)
    {
        array[str[i]] ++;
    }
    return LinkNode(array);
}

// 创建结点, 并连接这些结点
HuffTree *LinkNode(ElemType *array)
{
    static LinkList list;
    list.size = 0;
    for (int i = 0; i < MAX_SIZE; i++)
    {
        if ( 0 != array[i] )
        {
            HuffNode *newNode = (HuffNode *)malloc(sizeof(HuffNode));
            newNode->data = (char)i;
            newNode->left = NULL;
            newNode->right = NULL;
            sortNode(&list, newNode, array[i]);
        }
    }
    return createHuffTree(&list);
}

// 给结点排序(从小到大)
void sortNode(LinkList *list, HuffNode *newNode, int cnt)
{
    if ( list->size > MAX_SIZE )
    {
        printf(" out of size !\n");
        exit(0);
    }
    HuffTree *listNode = (HuffTree *)malloc(sizeof(HuffTree));
    listNode->Hnode = newNode;
    listNode->cnt = cnt;
    listNode->next = NULL;
    if ( 0 == list->size )
    {
        list->first = listNode;
        list->size ++;
    }
    else
    {
        if (list->first->cnt >= cnt)
        {
            listNode->next = list->first;
            list->first = listNode;
            list->size ++;
            return;
        }
        HuffTree *temp = list->first;
        while ( temp->next )
        {
            if ( temp->next->cnt >= cnt )
            {
                listNode->next = temp->next;
                temp->next = listNode;
                list->size ++;
                return;
            }
            temp = temp->next;
        }
        temp->next = listNode;
    }
}

// 创建Huffman树
HuffTree *createHuffTree(LinkList *list)
{
    while ( list->first )
    {
        HuffTree *cnn = (HuffTree *)malloc(sizeof(HuffTree));
        HuffNode *node = (HuffNode *)malloc(sizeof(HuffNode));
        cnn->Hnode = node;

        cnn->Hnode->left = list->first;
        cnn->Hnode->right = list->first->next;

        cnn->cnt = cnn->Hnode->left->cnt + cnn->Hnode->right->cnt;
        cnn->next = NULL;
        list->size --;
        list->first = list->first->next->next;
        insertNode(list ,cnn);
        if ( list->size <= 1 )
        {
            return cnn;
        }
    }
}

// 插入Huffman树结点,并排序(从小到大)。
void insertNode(LinkList *list, HuffTree *cnn)
{
    if ( !list->first )
    {
        return;
    }
    if (cnn->cnt <= list->first->cnt)
    {
        cnn->next = list->first;
        list->first = cnn;
        return;
    }
    else
    {
        HuffTree *temp = list->first;
        while ( temp->next )
        {
            if (temp->next->cnt >= cnn->cnt)
            {
                cnn->next = temp->next;
                temp->next = cnn;
                return;
            }
            temp = temp->next;
        }
        temp->next = cnn;
    }
}

Encode.c

#include "statement.h"

// 给字符串编码
ElemType *encode(HuffTree *root, ElemType *str)
{
    Stack stack;
    createStack(&stack);
    recurse(root, &stack);
    destoryStack(&stack);
    return splice(code, str);
}

// 创建一个栈,记录走过的结点
void createStack(Stack *stack)
{
    stack->base = (ElemType *)malloc(MAX_SIZE * sizeof(ElemType));
    if ( !stack->base )
    {
        printf("Application failed!\n");
        exit(0);
    }
    stack->top = stack->base;
    stack->STACK_SIZE = MAX_SIZE;
}

// 递归遍历整棵树(回溯),找到每个字母对应的编码
void recurse(HuffTree *root, Stack *stack)
{
    if ( !root->Hnode->left )
    {
        ElemType c = root->Hnode->data;
        ElemType *temp = stack->base;
        int i=0;
        while ( temp != stack->top )
        {
            codeTable[(int) c][i] = *temp;
            i++;
            temp++;
        }
        stack->top --;
    }
    else
    {
        *(stack->top) = '0';
        stack->top ++;
        recurse(root->Hnode->left, stack);

        *(stack->top) =  '1';
        stack->top ++;
        recurse(root->Hnode->right, stack);

        stack->top --;
    }
}

// 根据字符串拼接编码
ElemType *splice(ElemType *code, ElemType *str)
{
    for (int i = 0; i < strlen(str); i++)
    {
        strcat(code, codeTable[(int) str[i]]);
    }
    return code;
}

// 销毁栈
void destoryStack(Stack *stack)
{
    free(stack->base);
    stack->base = stack->top = NULL;
    stack->STACK_SIZE = 0;
}

Decode.c

#include "statement.h"

// 解码
ElemType *decode(HuffTree *root, ElemType *code)
{
    HuffTree *temp = root;
    int i = 0;
    int index = 0;
    while ( i < strlen(code) )
    {
        if ( code[i] == '0' )
        {
            temp = temp->Hnode->left;
        }
        else
        {
            temp = temp->Hnode->right;
        }
        if ( !temp->Hnode->left )
        {
            resStr[index] = temp->Hnode->data;
            temp = root;
            index ++;
        }
        i++;
    }
    destroyHuffTree(root);
    return resStr;
}

// 递归销毁整棵树
void destroyHuffTree(HuffTree *root)
{
    if ( root->Hnode->left || root->Hnode->right)
    {
        destroyHuffTree(root->Hnode->left);
        free(root->Hnode->left->Hnode);
        free(root->Hnode->left);
        root->Hnode->left = NULL;

        destroyHuffTree(root->Hnode->right);
        free(root->Hnode->right->Hnode);
        free(root->Hnode->right);
        root->Hnode->right = NULL;
    }
}

  运行结果 ：

​ 

小摆子*^_^*
关注
  • 25
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
哈夫曼树编码的实现+图解（含全部代码）
Initial_Mind的博客
04-23 9万+
只能说太用心了
哈弗曼编码
chuanjianhou0330的博客
04-29 319
完整的哈弗曼编码代码： //haffman 树的结构 typedef struct { //叶子结点权值 unsigned int weight; //指向双亲，和孩子结点的指针 unsigned int parent; unsign...
霍夫曼树：霍夫曼编码(Huffman Tree:Huffman Coding)
最新发布
Hacket_Xu的博客
12-03 1376
预计阅读时间：10分钟接上回 之前我们了解了霍夫曼树，今天我们来了解一下霍夫曼编码。 霍夫曼树常处理符号编写工作。根据整组数据中符号出现的频率高低，决定如何给符号编码。如果符号出现的频率越高，则给符号的码越短，相反符号的号码越长。相关术语 霍夫曼编码就是再霍夫曼树上进行实现的。 从树根开始，从待译电文中逐个取码。若编码为0，就往左走；编码为1，就往右走，一旦到达了叶子节点，就是译出了一个字符；在从根出发，直到电文结束。 T:00 ;:00 A:10 C
Huffman树&&Huffman编码（附完整源码）
solar一抹阳光的专栏
03-07 1115
转载请注明出处：http://blog.csdn.net/ns_code/article/details/19174553 Huffman Tree简介     赫夫曼树（Huffman Tree），又称最优二叉树，是一类带权路径长度最短的树。假设有n个权值{w1,w2,...,wn}，如果构造一棵有n个叶子节点的二叉树，而这n个叶子节点的权值是{w1,w2,...,wn}
哈夫曼树-创建，编码，解码，带权路径长度（含全部代码）
关注网络安全、云原生安全
02-04 1万+
主要函数： void CreateHT()创建哈夫曼树 void Code() 哈夫曼树编码 void Encode() 哈夫曼树解码 void WPL() 计算带权路径长度 所选实例： 所选实例 创建哈夫曼树 步骤： 假设有n个权值，则构造出的哈夫曼树有n个叶子结点。 n个权值分别设为 w1、w2、…、wn，则哈夫曼树的构造规则为： (1) 将w1、w2、…，wn看成...
赫夫曼编码_Huffman编码_源码
10-02
3. **生成编码**：从赫夫曼树中生成编码的方式是，从根节点到每个叶子节点的路径定义了该叶子节点（字符）的编码。一般来说，向左的分支表示0，向右的分支表示1。因此，路径越短，字符出现的频率越高。 4. **解码**...
huffman_编码_霍夫曼树_源码
10-04
它基于一种称为霍夫曼树（Huffman Tree）的数据结构，也被称为最优二叉树或最小带权路径长度树。这个压缩过程是通过为每个字符分配一个唯一的二进制码字，使得频繁出现的字符拥有较短的编码，从而减少总的编码长度。...
C语言实现Huffman编码源码
05-29
本资源为电子科技大学电子工程学院专业课嵌入式系统原理的一道作业题
Huffman编码C语言源码
04-28
在解压缩阶段，读取已编码的二进制流，根据Huffman编码表逐位解析，沿着Huffman树的分支找到对应字符，从而恢复原始文本。解码过程也需要维护Huffman树，但通常只需要使用编码表，而无需重新构建整个树。 在提供的...
基于Huffman树的文件压缩C源码
12-24
总结来说，"基于Huffman树的文件压缩C源码"涉及了数据结构（二叉树）、算法（Huffman编码）以及文件I/O操作，是一个综合性的编程实践项目。通过理解Huffman编码的工作原理和C语言的实现，可以更好地掌握数据压缩技术...
霍夫曼树代码
06-04
huffman代码 数据结构实验代码 霍夫曼编码
哈夫曼树编码参考代码
05-01
哈夫曼树编码参考程序 含 h头文件 main函数分开
霍夫曼树实现编码解码C语言实现
10-18
本资源为利用了Huffman树这样一种常用的数据结构实现了对一个指定文件的编码和解码功能。
哈夫曼树及哈夫曼编码详解【完整版代码】
热门推荐
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
哈夫曼树（C语言）
chenshengnanii的博客
05-29 1756
一、定义 哈夫曼树（Huffman Tree）是在叶子结点和权重确定的情况下，带权路径长度最小的二叉树，也被称为最优二叉树。 二、代码 #include <stdio.h> #include <stdlib.h> #include <string.h> #define N 30 #define Max 2*N-1 typedef char **HuffmanCode; typedef struct HTNode { double w..
哈夫曼树详细讲解（带例题和C语言代码实现——全注释）
qq_41199852的博客
12-02 1万+
** 哈夫曼树详细讲解（带例题和C语言代码实现——全注释） ** 定义
Huffman树与Huffman编码
飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘
11-18 2132
Huffman树与Huffman编码 问题描述 已知某系统在通信联络中只可能出现6种字符，其使用频度如下表所示： 根据Huffman编码原理，为6种字符设计一种Huffman编码方案。 算法分析与设计 (1)Huffman算法 ①根据给定的n个权值{w1,w2,…,wn}构造n棵二叉树的集合F={T1,T2,…,Tn}，其中每棵二叉树Ti中只有一个带权为wi的根结点，其左右子树均空。 ②在F中选取两棵根结点的权值最小的树作为左右子树构造一棵新的二叉树，且置新的二叉树的根结点的权值为其左、右子树上根结点的权
【算法】不妨用数组实现哈夫曼树的生成
微凉秋意的博客
05-18 1245
🎉每一个不曾起舞的日子，都是对生命的辜负🎉 🎉写在前面 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，哈夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码(有时也称为霍夫曼编码)。 ......
数据结构——哈夫曼树的实现以及编码（C语言实现）
欢迎来到Gorit的博客
11-29 5万+
1、问题描述       利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。构造哈夫曼树时，首先将由n个字 符形成的n个叶子结点存放到数组HuffNode的前n个分量中，然后根据哈夫曼方法的基本思想，不断将两个较小的子树合并为一个 较大的子树，每次构成的新子树的根结点顺序放到HuffNode数组中的前n个分量的后面。        通俗的来讲，哈弗曼树就是一种广...
自适应Huffman编码实现与优化
在Huffman树中，频率高的字符被分配到较短的编码，而频率低的字符则获得较长的编码，从而使得平均编码长度最短，达到压缩数据的目的。 静态Huffman编码是基于预先知道的字符频率构建的编码树，一旦构建完成，编码树...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值