数据结构（四）树---哈夫曼树了解以及代码实现

最新推荐文章于 2023-11-09 23:16:26 发布
最新推荐文章于 2023-11-09 23:16:26 发布
阅读量281 收藏 1
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/ssyfj/p/9472733.html
版权

哈夫曼树

（一）定义

带权路径长度WPL：

哈夫曼树（最优二叉树）：

WPL最小的二叉树

（二）构造

将权值从小到大排序，后将权值最小的两个并在一起成新的二叉树
A5,E10,B15,D30,C40

（三）哈夫曼树特点

1.没有度为1的结点

2.n个叶子节点的哈夫曼树共有2n-1个结点

树的特点：度为2结点和叶结点的关系n2=n0-1
所以：当叶结点为n时，度为二的结点数为n-1
因为哈夫曼没有度为一的结点，所以一共在树中有2n-1个结点

3.哈夫曼树任意非叶结点的左右子树交换后还是哈夫曼树

4.对同一组权值{w1,w2,...,wn},是会存在不同结构的哈夫曼树

哈夫曼编码

固定一段字符串，如何对字符串进行编码，可以使得该字符串的编码存储空间最少
例如一串文字BADCADFEED,我们要在网络中传递，显然是要传递二进制(0/1)来表示。

法一：直接传递字符的ASCII码，每个字符占八位，一共传递80位

法二：我们发现数据只是从A-F,一共6个字符，我们完全可以使用3位二进制来表示这些数据（网络对方需要知道我们的编码才能解码）

001000011010000011101100100011(30)

变为传递30位数据，对法一进行了极大的优化。

法三：我们发现一段文字中各个数字出现的频率是不一样的，各个字母频率相加100%，可以使用哈夫曼编码，对数据再次进行压缩

假设各个字母频率为
A 27,B 8,C 15,D 15,E 30,F 5

1.先构造哈夫曼树

 

2.获取前缀码

（1）左右分支分别用0，1表示（避免了二义性）
（2）字符只在叶子节点

哈夫曼压缩后的数据二进制串:1001010010101001000111100(25)

哈夫曼编码实现

头文件

#pragma once
#ifndef _HUFFMAN_H
#define _HUFFMAN_H

//下面两个结构体对于霍夫曼树
typedef struct _htNode
{
    char symbol;
    struct _htNode* left, *right;
}htNode;

typedef struct _htTree
{
    htNode* root;
}htTree;

//下面两个结构体对应霍夫曼编码表
typedef struct _hlNode
{
    char symbol;
    char* code;        //类似'0001\0'
    struct _hlNode* next;
}hlNode;

typedef struct _hlTable
{
    hlNode *first;
    hlNode *last;
}hlTable;

//根据字符串创建霍夫曼树
htTree* buildTree(char* str);
//根据霍夫曼树创建霍夫曼前缀码表
hlTable* buildTable(htTree* HT);
//根据字符串进行编码，str是一串ASCII码字符串
void encode(hlTable* ht, char *str);
//根据霍夫曼树，进行解码,str类似于'00001101'
void decode(htTree* ht,char *str);

#endif // !_HUFFMAN_H
huffman.h 
#pragma once
#ifndef _QUEUE_H
#define _QUEUE_H

#include "huffman.h"

#define TYPE htNode *

#define MAX_SZ 256

typedef struct _pQueueNode
{
    TYPE val;
    unsigned int priority;
    struct _pQueueNode* next;
}pQueueNode;

typedef struct _pQueue
{
    pQueueNode* first;
    unsigned int size;    //无符号扩大空间
}pQueue;

void initPQueue(pQueue** queue);    //初始化队列
void addPQueue(pQueue** queue,TYPE val,unsigned int priority);    //添加数据
TYPE getPQueue(pQueue** queue);    //获取数据

#endif
queue.h

源文件

#include "queue.h"
#include <stdio.h>
#include <stdlib.h>

//初始化队列
void initPQueue(pQueue** queue)
{
    *queue = (pQueue*)malloc(sizeof(pQueue));
    (*queue)->size = 0;
    (*queue)->first = NULL;    //初始化头指针
}

//添加数据,这里不是简单添加到队列队尾，而是按照优先级
void addPQueue(pQueue** queue, TYPE val, unsigned int priority)
{
    pQueueNode *aux,*cur;    //aux是新加入结点，cur是优先级判断的游标
    //满队列
    if ((*queue)->size == MAX_SZ)
    {
        printf("\nQueue is full\n");
        return;
    }
    //创建该新的结点
    aux = (pQueueNode*)malloc(sizeof(pQueueNode));
    aux->priority = priority;
    aux->val = val;
    
    //若是空队列，直接加入
    if ((*queue)->size == 0 || !(*queue)->first)
    {
        aux->next = NULL;
        (*queue)->first = aux;
        (*queue)->size++;
        return;
    }
    else
    {
        //进行循环判断优先级,优先级低的在前面，根据霍夫曼编码，每次或取出两个最小的进行合并
        //首先判断，优先级小于首结点
        if (priority<=(*queue)->first->priority)
        {
            aux->next=(*queue)->first;
            (*queue)->first = aux;
            (*queue)->size++;
            return;
        }
        else
        {
            cur = (*queue)->first;    
            while (cur->next)    //上面的if判断过首结点，我们这里只需要判断他下面结点即可
            {
                if (priority <= cur->next->priority)    
                {
                    aux->next = cur->next;
                    cur->next = aux;
                    (*queue)->size++;
                    return;
                }
                cur = cur->next;
            }
            //直到走到末尾，发现全部优先级都比他低，所以加入结尾
            if (cur->next == NULL)
            {
                aux->next = NULL;
                cur->next = aux;
                (*queue)->size++;
                return;
            }
        }
    }
}

//获取数据
TYPE getPQueue(pQueue** queue)
{
    TYPE returnVal;
    if ((*queue)->size == 0 || (*queue)->first == NULL)
    {
        printf("queue is empty\n");
        return;
    }
    
    returnVal = (*queue)->first->val;
    (*queue)->first = (*queue)->first->next;
    (*queue)->size--;

    return returnVal;
}
queue.c 
#include "huffman.h"
#include "queue.h"
#include <stdio.h>
#include <stdlib.h>

//根据字符串创建霍夫曼树
htTree* buildTree(char* str)
{
    //先创建一个字符统计数组
    int proprity[256] = { 0 };
    for (int j = 0; j < strlen(str);j++)
    {
        proprity[(unsigned char)str[j]]++;
    }

    //创建一个队列，利用队列来创建一个完整的霍夫曼树
    pQueue *queue;
    initPQueue(&queue);

    for (int k = 0; k < 256;k++)
    {
        if (proprity[k]!=0)
        {
            htNode* hn = (htNode*)malloc(sizeof(htNode));
            hn->left = NULL;
            hn->right = NULL;
            hn->symbol = (char)k;
            addPQueue(&queue, hn, proprity[k]);
        }
    }

    //将所有队列中的数据开始合并
    while (queue->size != 1)
    {
        htNode* left, *right,*tnode;
        //优先级必须从这里获取
        int proprity = queue->first->priority;
        proprity += queue->first->next->priority;
        //下面返回的是霍夫曼结点，其中不含有优先级
        left = getPQueue(&queue);
        right = getPQueue(&queue);
        tnode = (htNode*)malloc(sizeof(htNode));
        tnode->left = left;
        tnode->right = right;
        
        addPQueue(&queue, tnode, proprity);
    }

    //队列中最后一个元素就是霍夫曼树的根节点，我们将它赋值给霍夫曼树即可
    htTree *ht = (htTree*)malloc(sizeof(htTree));
    ht->root = getPQueue(&queue);
    return ht;
}

//我们通过遍历到二叉树叶子节点，从而获取到前缀码
void preOrderGetTb(htNode* root,hlTable **table,int level, char* code)
{
    if (root->left||root->right)
    {
        if (root->left)
        {
            code[level] = '0';
            preOrderGetTb(root->left, table,level+1,code);
        }

        if (root->right)
        {
            code[level] = '1';
            preOrderGetTb(root->right, table, level + 1, code);
        }
    }
    else
    {
        code[level] = '\0';
        hlNode* aux = (hlNode*)malloc(sizeof(hlNode));
        aux->symbol = root->symbol;
        aux->code = (char*)malloc(sizeof(char)*(level + 1));
        strcpy(aux->code, code);
        aux->next = NULL;
        if ((*table)->first==NULL)
        {
            (*table)->first = aux;
            (*table)->last = aux;
        }
        else
        {
            (*table)->last->next = aux;
            (*table)->last = aux;
        }
    }
}


//根据霍夫曼树创建霍夫曼前缀码表
hlTable* buildTable(htTree* HT)
{
    hlTable* hl;
    hl = (hlTable*)malloc(sizeof(hlTable));
    hl->first = NULL;
    hl->last = NULL;

    int k = 0;
    char code[255] = { 0 };

    preOrderGetTb(HT->root, &hl, k, code);
    return hl;
}

//根据字符串进行编码，str是一串ASCII码字符串
void encode(hlTable* table, char *str)
{
    hlNode* cur = table->first;
    char *s = str;
    while (*s!='\0')
    {
        while (cur->symbol!=*s)
            cur = cur->next;
        printf("%s", cur->code);
        s++;
        cur = table->first;
    }
}

//根据霍夫曼树，进行解码,str类似于'00001101'
void decode(htTree* ht, char *str)
{
    char* s = str;
    htNode* tn = ht->root;
    while (*s!='\0')
    {
        if (*s=='0')
        {
            tn = tn->left;
            if (!tn->left&&!tn->right)
            {
                printf("%c", tn->symbol);
                tn = ht->root;
            }
        }
        else
        {
            tn = tn->right;
            if (!tn->left&&!tn->right)
            {
                printf("%c", tn->symbol);
                tn = ht->root;
            }
        }
        s++;
    }
}
huffman.c 
#include "huffman.h"
#include "queue.h"
#include <stdio.h>
#include <stdlib.h>


int main()
{
    htTree *ht;
    hlTable *hl;
    ht = buildTree("i love www.fishc.com");//创建霍夫曼树
    hl = buildTable(ht);    //根据霍夫曼树创建前缀码表
    encode(hl, "i love www.fishc.com");    //根据前缀码表获取全部前缀码
    decode(ht, "000001010010111110");//oimfw
    system("pause");
    return 0;
}

int main()
{
    htTree *ht;
    hlTable *hl;
    ht = buildTree("aaaauxxz");//创建霍夫曼树
    hl = buildTable(ht);    //根据霍夫曼树创建前缀码表
    encode(hl, "aaaauxxz");    //根据前缀码表获取全部前缀码
    decode(ht, "1101001000000");//aaxuzz

    system("pause");
    return 0;
}

补充：

1.编写代码前先实现队列的操作

2.队列实现是优先级队列，优先级低的放在前面

3.队列中存放的是哈夫曼树节点， 我们每次从队列中获取两个优先级最低的，进行合并，优先级为二者之和，然后又放回队列中。

4.直到我们队列中只有一个结点，这就是我们的根节点，结点下面是带有我们所有数据的哈夫曼树

5.获取哈夫曼树后，我们根据递归一路找到叶子结点（字符），将路径转前缀码，根据结点字符和路径前缀码，创建前缀码表

6.根据前缀码表，我们可以获取到各个字符的前缀码，然后进行编码即可

7.我们同样可以根据前缀码串，通过对哈夫曼树的遍历，找到前缀码对应的字符

 

转载于:https://www.cnblogs.com/ssyfj/p/9472733.html

weixin_30267691
关注
数据结构（二十） -- C语言版 -- 树 - 霍夫曼树（哈夫曼树、赫夫曼树、最优二叉树）、霍夫曼编码
青椒*^_^*凤爪爪的博客
07-04 5330
霍夫曼树也称为称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度 霍夫曼编码，又译为哈夫曼编码、赫夫曼编码，。是一种用于无损数据压缩的熵编码（权编码）算法。由美国计算机科学家大卫·霍夫曼（David Albert Huffman）在1952年发明。
数据结构，哈夫曼树编码
06-27
可以打开文档读取文档中的字符，并对其进行哈夫曼编码，生成哈夫曼代码，保存至文档。还可以在对编码进行译码，保存至文档。
哈夫曼树代码实现(数据结构课设)
06-02
这是数据结构课设 哈夫曼树的c语言实现 大家可以借鉴一下
数据结构————哈夫曼树的实现
xjsc01的博客
04-15 596
效果图： 代码： #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct { int first;//表示pair对中的第一关键字 int second; }two; typedef struct PQueue { two *data; int size; int max_size; }PQueue; typede.
数据结构-哈夫曼树用代码实现07
FairLikeSnow的博客
02-17 494
哈夫曼树用代码实现 请看代码: 例子用的上一节，请自行对比 #include<iostream> #include<deque> #include<vector> #include<algorithm> using namespace std; typedef struct _HuffumanTree { int weight;//权值 _Hu...
数据结构——赫夫曼树（Java代码实现）
共勉
05-21 530
➢ 基本介绍 给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度(WPL)达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树。 赫夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 ➢ 概念说明 路径和路径长度：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。 结点的权及带权路径长度：若将树中结点赋给一个有着某种含 义的数值，则这个数值称为该结点的权。结点的带权
哈夫曼树及其编码 数据结构课程设计 （源代码附实验报告）
09-09
哈夫曼树及其编码 数据结构课程设计 （源代码附实验报告） 已调试成功
四川大学计算机学院-数据结构与算法分析高分实验报告-改进哈夫曼树类模板.rar
08-18
通过这份实验报告，读者不仅能掌握哈夫曼树的基本知识，还能了解到在实际应用中如何改进和优化，从而提升对数据结构和算法的理解与应用能力。 总的来说，这份来自四川大学计算机学院的实验报告全面且深入地探讨了...
数据结构-实验三-题目二：哈夫曼树.docx
10-11
数据结构-实验三-题目二：哈夫曼树 本实验报告的主要内容是对哈夫曼树的实现，包括初始化、建立编码表、编码、译码和打印等操作。实验要求掌握二叉树的根本操作和赫夫曼树的思想和相关概念，并学习使用二叉树解决...
数据结构-实验三-题目二：哈夫曼树 (3).docx
06-18
"数据结构-实验三-题目二：哈夫曼树" 本实验报告的主要内容是实现哈夫曼树的编码和解码过程，通过选择二叉树结构实现赫夫曼编/解码器。该实验的主要目的在于掌握二叉树基本操作的实现方法，了解赫夫曼树的思想和...
【数据结构X.11】代码实现 哈夫曼树的创建，建立，构造，实现哈夫曼编码
清凌的博客
12-13 2006
哈夫曼树的各种语言java，python，c++ 代码实现哈夫曼树的创建，建立，构造，实现哈夫曼编码，实现思路和要点： 抓住哈夫曼树的性质，每轮选出2个权值最小的点进行构造树。 抓住哈夫曼编码的性质，从根出发，向左标0，向右标1. 哈夫曼树的构造思路： 已知某系统在通信联络中只可能出现8种字符，其概率分别为0.05,0.29,0.07,0.08,0.14,0.23,0.03,0.11 试着设计赫夫曼编码。 假设权w=（5，29，7，8，14，23，3，11），n=8，则m=15，按照上述算法构造一颗哈夫曼树
数据结构哈夫曼树实验代码
02-18
数据结构基于C++的书实验的代码,有需要的可以下载参考
数据结构--哈夫曼树的基本代码
12-22
数据结构--哈夫曼树的基本代码 数据结构的重点算法之一
哈夫曼树 数据结构
07-11
构造哈夫曼树的算法实现： 假设哈夫曼树采用双亲孩子表示法存储，并增加权值域，构造哈夫曼树的叶子结点（树木的权）有N个，合并次数为N—1次，则森林中总共有2N—1棵树，（包含合并后删除的）。
哈夫曼树的建立与编码及译码
11-07
数据结构实验，实现哈夫曼树的创建，并且实现编码和译码功能，满足任意字符串的输入，输出编码；也可满足任意编码输入，输出字符串。在创建哈夫曼树时输入权值与对应的字符。
数据结构【完整代码】之（C语言实现【哈夫曼树的存储结构与创建】）
Zhou_LC的博客
11-28 1411
本文包含两个文件的代码和一张测试效果图： HuffmanTree.h文件： 哈夫曼树的存储结构与创建函数 HuffmanCreatTest.cpp文件： 用于测试 效果图：（如下） 效果图： HuffmanTree.h文件： #include <stdio.h> #include <stdlib.h> typedef struct{ int weight; int parent,lchild,rchild; }HTNode, *HuffmanTree; void S
哈夫曼树构造的代码实现嗯嗯
weixin_45911345的博客
12-04 438
建议先学习哈夫曼树原理再来看该博客的代码实现 相关概念 叶子结点的权值：叶子结点的数值量，如某个字符出现的频率，修路的费用等 二叉树的带权路径长度：设二叉树有n个带权值的叶子结点，从根结点到各个叶子结点的路径长度与该叶结点的权值乘积的和 哈夫曼树：给定一组带权值的叶结点，带权路径长度最小的二叉树 哈夫曼树构造过程 对于n个带权叶结点，我们每次合并两个结点为一个，要经过n-1次合并我们才能合并成一棵哈夫曼树，而且这棵树有n-1个非叶结点，n个叶结点，一共有2*n-1个结点。其实细节很多，还是看代码把，读代码总
数据结构：哈夫曼树、哈夫曼编码
m0_63544124的博客
02-14 520
哈夫曼树、哈夫曼编码 public class HuffmanTree { public static void main(String[] args) { int[] arr = {13, 7, 8, 3, 29, 6, 1}; Node root = creatHuffmanTree(arr); preOrderTree(root); } //创建一颗哈夫曼树 public static Node c.....
【数据结构】哈夫曼树和哈夫曼编码 完整代码
最新发布
2301_76172693的博客
11-09 801
【代码】【数据结构】哈夫曼编码完整代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值