哈夫曼树以及应用（哈夫曼编码）概念和建立——附带实现代码以及习题

最新推荐文章于 2023-12-23 19:32:32 发布
最新推荐文章于 2023-12-23 19:32:32 发布
阅读量565 收藏 1
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33375598/article/details/104286740
版权

1 概念

1.1 哈夫曼树

  • 定义：n个带权叶子结点的二叉树中，带权路径长度最小的二叉树。
    • 权：树结点被赋予一个某种一亿的数值；
    • 带权路径长度：从树根结点到任意结点的路径长度（经过的边数）与该结点上权值的乘积。
  • 性质：
    • 1 哈夫曼树可以不唯一，但最小带权路径长度一定是唯一的；
    • 2 哈夫曼树只有度为1的结点；
    • 3 权越小的结点，离根结点越远。

1.2 哈夫曼编码

  • 前缀码：任何一个字符的编码都不是另一个编码的前缀。
  • 前缀码存在意义：不产生混淆，让解码能正常进行。
  • 哈夫曼编码背景：
    • 对于一个给定字符串，有多种前缀码方式，为了信息传递的效率，尽量选择长度最短的编码方式。
    • 把每个字符出现的次数（频率）作为各自叶子结点的权值，那么字符编码成01串的长度为这颗树的带权路径长度。
    • 而带权路径长度最小的树为哈夫曼树。
  • 定义：由哈夫曼树产生的编码方式为哈夫曼编码。

2 实现

2.1 哈夫曼树

  • 构造思想：反复选择两个最小的元素，合并，直到只剩一个元素。
  • 实现方式：堆或优先队列

2.1.2 示例

合并果子
　　在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。

因为还要花大力气把这些果子搬回家，所以多多在合并果子时要尽可能地节省体力。假定每个果子重量都为1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使多多耗费的体力最少，并输出这个最小的体力耗费值。
　　例如有3种果子，数目依次为1，2，9。可以先将1、2堆合并，新堆数目为3，耗费体力为3。接着，将新堆与原先的第三堆合并，又得到新的堆，数目为12，耗费体力为12。
所以多多总共耗费体力=3+12=15。可以证明15为最小的体力耗费值。
输入
　　输入包括两行，第一行是一个整数n(1<＝n<=10000)，表示果子的种类数。
　　第二行包含n个整数，用空格分隔，第i个整数ai(1<＝ai<=20000)是第i种果子的数目。
输出
　　输出包括一行，这一行只包含一个整数，也就是最小的体力耗费值。输入数据保证这个值小于2^31。

样例输入 Copy
3
1 2 9
样例输出 Copy
15
  • 方法一（优先队列）：
#include <cstdio>
#include <queue>

using std::vector;
using std::priority_queue;
using std::greater;

//小顶堆优先队列
priority_queue<long long, vector<long long>, greater<long long>> q;

int main(int argc, char const *argv[])
{
    int n;
    long long temp, x, y ,ans = 0;
    
    scanf("%d", &n);

    for (int i = 0; i < n; ++i)
    {
        scanf("%lld", &temp);
        q.push(temp);
    }

    while(q.size() > 1){
        x = q.top();
        q.pop();

        y = q.top();
        q.pop();

        q.push(x + y);
        ans += x + y;
    }

    printf("%lld\n", ans);
    return 0;
}
  • 方法二：小顶堆
#include <cstdio>
#include <algorithm>

using std::swap;

const int MAXN = 20010;
long long heap[MAXN];
int n;

void downAdjust(int low, int high){
    int i = low, j = i * 2;
    while(j <= high){
        if(j + 1 <= high && heap[j + 1] < heap[j]){
            j = j + 1;
        }

        if(heap[j] < heap[i]){
            swap(heap[j], heap[i]);
            i = j;
            j = i * 2;
        }else{
            break;
        }
    }
}

void createHeap(){
    for (int i = n / 2; i >= 1; ++i)
    {
        downAdjust(i, n);
    }
}

void deleteTop(){
    heap[1] = heap[n--];
    downAdjust(1, n);
}

void upAdjust(int low, int high){
    int i = high, j = i / 2;
    while(j >= low){
        if(heap[j] > heap[i]){
            swap(heap[j], heap[i]);
            i = j;
            j = i / 2;
        }else{
            break;
        }
    }

}

void Insert(int x){
    heap[++n] = x;
    upAdjust(1, n);
}

int main(int argc, char const *argv[])
{
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i)
    {
        scanf("%lld", &heap[i]);
    }

    createHeap();

    long long ans = 0;
    long long x, y;
    while(n > 1){
        x = heap[1];
        deleteTop();
        y = heap[1];
        deleteTop();

        Insert(x + y);
        ans += x + y;
    }

    printf("%lld\n", ans);
    return 0;
}

2.2 哈夫编码

2.2.1 从叶子到根的逆向顺序构造哈夫曼编码

#include <cstdio>
#include <cstring>
#include <limits.h>
#include <algorithm>

using std::swap;
using  std::strcpy;

typedef char *HuffmanCode;

const int MAXN = 110;

typedef struct{
    int weight;
    int lchild, rchild, parent;
}HuffmanNode, *HuffmanTree;

void selectMin(HuffmanTree HT, int n, int &s1, int &s2){
    int min = INT_MAX;
    for (int i = 1; i <= n; ++i) {
        if(HT[i].parent == 0 && min > HT[i].weight){
            min = HT[i].weight;
            s1 = i;
        }
    }

    min = INT_MAX;
    for (int j = 1; j <= n; ++j) {
        if(HT[j].parent == 0 && min > HT[j].weight && j != s1){
            min = HT[j].weight;
            s2 = j;
        }
    }

    if(s1 > s2){
        swap(s1, s2);
    }

}

void HuffmanCoding(HuffmanTree &HT, HuffmanCode *&HC,int w[],int n){
    // w存放n个字符的权值（均>0）,构造哈夫曼树HT，并求出n个字符的哈夫曼树编码HC
    if(n <= 1) return;
    int m = 2 * n -1;//树的所有结点个数
    //0号单元未用
    HT = new HuffmanNode[m + 1];

    //初始化叶子结点
    for (int i = 1; i <= n; ++i) {
        HT[i].weight = w[i];
        HT[i].lchild = HT[i].rchild = HT[i].parent = 0;
    }
    //初始化非叶子结点
    for (int i = n + 1; i<= m; ++i) {
        HT[i].lchild = HT[i].rchild = HT[i].parent = 0;
    }


    for (int i = n + 1; i <= m; ++i)//建立哈夫曼树
    {
        int s1, s2;
        //在HT[1~i-1]中选择parent为0且weight最小的两个结点，其序号分别为s1,s2
        selectMin(HT, i - 1, s1, s2);
        HT[s1].parent = HT[s2].parent = i;
        HT[i].lchild = s1;
        HT[i].rchild = s2;
        HT[i].weight = HT[s1].weight + HT[s2].weight;

    }
    //从叶结点到根逆向求每个字符的哈夫曼编码
    HC = new HuffmanCode[n + 1];
    //分配n个字符编码的头指针向量([0]不用)
    char* cd = new char[n];//分配编码工作空间

    cd[n - 1] = '\0';//编码结束符

    for (int i = 1; i <= n; ++i)//逐个字符求哈夫曼编码
    {
        int star = n - 1;//编码结束位置
        for (int c = i, f = HT[i].parent;f != 0; c = f, f = HT[f].parent)
        {
            //从叶结点到根逆向求编码
            if(HT[f].lchild == c){
                cd[--star] = '0';
            }else{
                cd[--star] = '1';
            }
        }
            //为第i个字符串编码分配空间，最后一个空间作为结束符
            HC[i] = new char[n - star];
            //从cd复制编码（串）到HC
            strcpy(HC[i], cd + star);
    }
    delete []cd;//释放工作空间
}

int main(){
    HuffmanTree HT;
    HuffmanCode *HC;
    int n;
    int data[MAXN];

    while(scanf("%d", &n) != EOF){
        for (int i = 1; i <= n; ++i) {
            scanf("%d", &data[i]);
        }

        HuffmanCoding(HT, HC, data, n);

        for (int j = 1; j <= n; ++j) {
            printf("%s\n", HC[j]);
        }

        delete(HT);
        delete(HC);
    }

    return 0;
}
/*
哈夫曼的层序遍历为：100，42，58，23，19，29，29，11，8，14，15，5，3，7，8
Input:
8
5 29 7 8 14 23 3 11
Output:
0110
10
1110
1111
110
00
0111
010
 */

2.2.2 根出发直到叶子构造赫夫曼编码

#include <cstdio>
#include <limits.h>
#include <algorithm>
#include <cstring>

using std::swap;
using std::strcpy;

typedef char *HuffmanCode;
const int MAXN = 110;

typedef struct
{
    int parent, lchild, rchild;
    int weight;
}HuffmanNode, *HuffmanTree;

void selectMin(HuffmanTree HT, int n, int &s1, int &s2){
    int min = INT_MAX;
    for (int i = 1; i <= n; ++i) {
       if(HT[i].parent == 0 && min > HT[i].weight){
           min = HT[i].weight;
           s1 = i;
       }
    }

    min = INT_MAX;
    for (int i = 1; i <= n; ++i) {
        if(HT[i].parent == 0 && min > HT[i].weight && i != s1){
            min = HT[i].weight;
            s2 = i;
        }
    }

    if(s1 > s2){
        swap(s1, s2);
    }
}

//无栈非递归遍历哈夫曼树，求哈夫曼编码
void HuffmanCoding(HuffmanTree &HT, HuffmanCode *&HC, int w[], int n){
    if(n <= 1) return;
    int m = 2 * n - 1;

    HT = new HuffmanNode[m + 1];
    //分配n个字符编码的头指针向量[0]不用

    for (int i = 1; i <= n; ++i) {
        HT[i].weight = w[i];
        HT[i].parent = HT[i].lchild = HT[i].rchild = 0;
    }

    for (int i = n + 1; i <= m; ++i) {
        HT[i].parent = HT[i].lchild = HT[i].rchild = 0;
    }

    //构建哈夫曼树
    for (int i = n + 1; i <= m; ++i) {
        int s1, s2;
        selectMin(HT, i - 1, s1, s2);
        HT[i].lchild = s1;
        HT[i].rchild = s2;
        HT[s1].parent = HT[s2].parent = i;
        HT[i].weight = HT[s1].weight + HT[s2].weight;
    }

    HC = new HuffmanCode[n + 1];
    char* cd = new char[n];
    int c = m;
    int cdlen = 0;
    cd[n - 1] = '\0';
    for (int i = 1; i <= m; ++i)
    {
        HT[i].weight = 0;//遍历哈夫曼树作结点状态标志
    }

    while(c) {
        if (HT[c].weight == 0) {//向左
            HT[c].weight = 1;
            if (HT[c].lchild != 0) {
                c = HT[c].lchild;
                cd[cdlen++] = '0';
            } else if (HT[c].rchild == 0) {//登记叶子结点的编码
                HC[c] = new char[cdlen + 1];
                cd[cdlen] = '\0';
                strcpy(HC[c], cd);//复制编码（串）
            }
        } else if (HT[c].weight == 1) {//向右
            HT[c].weight = 2;
            if (HT[c].rchild != 0) {
                c = HT[c].rchild;
                cd[cdlen++] = '1';
            }
        } else {//HT[c].weight == 2, 退回
            HT[c].weight = 0;
            c = HT[c].parent;
            --cdlen;//退回父结点，编码长度减一
        }

    }
    delete []cd;
}




int main(int argc, char const *argv[])
{
    HuffmanTree HT;
    HuffmanCode *HC;
    int n;
    int data[MAXN];

    while(scanf("%d", &n) != EOF){
        for (int i = 1; i <= n; ++i) {
            scanf("%d", &data[i]);
        }

        HuffmanCoding(HT, HC, data, n);
        for (int i = 1; i <= n; ++i) {
            printf("%s\n", HC[i]);
        }
        delete(HC);
        delete(HT);
    }

    return 0;
}
/*
Input:
8
5 29 7 8 14 23 3 11
Output:
0110
10
1110
1111
110
00
0111
010
 */
繁星蓝雨
关注
专栏目录
哈夫曼编码原理代码
code_mzh的博客
07-12 446
哈夫曼树─即最优二叉树，带权路径长度最小的二叉树，经常应用于数据压缩。通过将高频率字符用较短字节进行表示而不是统一表示的方法达到字符串的压缩。 啥是带权路径？- 每一个结点代表着不同的数字，而这些不同的数字称作结点的权值。 二叉树中一个结点到另一个结点经过的结点方式是唯一的，这些经过的结点称作两个结点之间的路径。而由结点A到结点B中间经历的结点数目加1即为结点A到B的路径长度。 哈夫曼为啥是前缀编码？ 因为**定长编码已经用相同的位数这个条件保证了任一个字符的编码都不会成为其它编码的前缀,**所以这种情
算法-哈夫曼编码
最新发布
纯洁的小魔鬼
06-25 2366
哈夫曼树能够根据字符出现的频率分配变长编码，使得高频字符使用较短的编码，低频字符使用较长的编码，从而最大程度地减少平均编码长度。这种自适应的编码方式使哈夫曼编码在很多实际应用中都能达到接近最优的压缩效果。频率越高的字符，经过的路径越短，则编码越短。最终的需要编码的所有字符都在叶子节点上。
构建哈夫曼树(可构造哈夫曼编码)
10-29
给定n个权值作为n的叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。使用数组构建哈夫曼树，并可用该树构造哈夫曼编码。
哈夫曼树的构造和哈夫曼编码实现详细讲解（含例题详细讲解）
热门推荐
qq_53668991的博客
05-10 1万+
哈夫曼树的构造和哈夫曼编码实现详细讲解（含例题详细讲解），以及例题详解：一个单位有5个部门，每个部门都有一部电话，但是整个单位只有一根外线，当有电话打过来的时候，由转接员转到内线电话，已知各部门使用外线电话的频率为（次/天）：5 16 912 19。利用哈夫曼树算法思想设计内线电话号码，使得接线员拨号次数尽可能少。
哈夫曼编码和译码&&c++重点知识的应用
changke的博客
11-24 1136
又是一个摸鱼天，啥都没学就写了个哈夫曼编码和译码。将以前学的c++相关知识系统的用了一遍，反正是能想到啥，啥方便就用啥，但是说回来，也没省多少事。反正比用c语言写跟简单一点。 先看题目原型吧！ 假设某通信报文的字符集由A,B,C,D,E,F这6个字符组成，它们在报文中出现的频度（频度均为整数值）。 (1)构造一棵哈弗曼树，依次给出各字符编码结果。 (2)给字符串进行编码。 (3)给编码串进行译码。...
hfm.rar_哈夫曼_哈夫曼树的建立_哈夫曼编码_哈夫曼编码 译码
09-14
哈夫曼编码是一种高效的数据压缩...总之，哈夫曼编码是数据压缩领域的一个重要概念，它利用了数据的统计特性，通过构建哈夫曼树来实现高效的编码和解码。在处理大量文本数据时，哈夫曼编码能显著提高存储和传输效率。
哈夫曼编码压缩和解压缩文件——C++实现
01-20
在C++实现哈夫曼编码压缩和解压缩文件时，需要理解二叉树、最小堆以及位操作等概念，同时还需要掌握文件操作和字符串处理。通过上述步骤，可以有效地对文件进行压缩和解压缩，实现数据的高效存储。
C++实现哈夫曼树编码解码
08-19
C++实现哈夫曼树编码解码 哈夫曼树是一种特殊的二叉树，它...C++实现哈夫曼树编码解码是通过使用HuffmanNode和HuffmanTree类来创建哈夫曼树，然后使用哈夫曼树来对数据进行编码和解码，以达到数据压缩和解压缩的目的。
【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 ************************************
哈夫曼树以及哈夫曼编码
znnzzzzznmxmnxn的博客
12-23 1458
目录哈夫曼编码例子基本原理（1）与哈夫曼树相关的基本概念（2）哈夫曼编码（3）哈夫曼树（4）哈夫曼编码算法的实现步骤 结果出现的问题及解决方法问题：自己的教科书上的函数算法中有很多变量没有声明。问题：函数中初始化语句for（i=n+1;i<=m;i++）ht[i]={0,0,0,0};编写运行有问题。问题：教科书上的函数没有编写输入各结点的权值的语句。问题：教科书上的select函数没有编写，无法实现从双亲结点为0的结点中挑选出权值最小的两个结点，并将这两个结点的下标号给P1、P2返回。 总结代码字符编码字
哈夫曼树&哈夫曼编码
qq_39957456的博客
08-28 716
哈夫曼树 Huffman Tree 给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。 哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 假设7个叶子节点依次为2,4,18,7,9,5和8. (1) 从小到大排序为2,4,5,7,8,9,18 (2) 取最小两个节点向上构造2+4=6， (3)重新排序得，5,6,7,8,9,18 重复步骤(1)(2)(3)直至剩下一个根节点，.
15哈夫曼树/哈夫曼编码
Tian Meng的博客
03-30 2384
哈夫曼编码的基本思想是，为频繁出现的字符分配较短的编码，为不频繁出现的字符分配较长的编码。这样做可以使得编码后的数据具有更高的压缩率。**例：**要传输的字符集 D = {C，A，S，T，;}（注意这个分号也是，并没有多打），每个字符出现的频率 W = {2，4，2，3，3}。由于哈夫曼编码采用可变长度编码，使得频繁出现的字符用较短的编码表示，不频繁出现的字符用较长的编码表示，因此可以达到比固定长度编码更高的压缩率。因为构造哈夫曼树的时候是，选用两小造新树。哈夫曼编码是一种可变长度编码的算法，用于将。
哈夫曼树的生成、编码、译码输出
qq_51871179的博客
11-12 556
数据结构上机实验，老师要求构建哈夫曼树哈夫曼编码，输出字符串的哈夫曼编码形式，以及根据一段密文根据哈夫曼编码还原成字符串。整体思路如下。
【哈夫曼树】实现哈夫曼树的创建；输出字符个数以及各个字符的权值；哈夫曼编码；哈夫曼译码。
qq_63794524的博客
11-15 1176
哈夫曼树的创建、编码、译码操作。
哈夫曼树编码译码
weixin_38166726的博客
09-19 1467
一：问题描述 【问题描述】 利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。试为这样的信息收发站写一个哈夫曼码的编/译码系统。【任务要求】 一个完整的系统应具有以下功能： 1) I：初始化...
哈夫曼树代码实现详解与应用
本文将详细介绍哈夫曼树的原理和在编码中的应用，特别是哈夫曼编码在数据通信中的重要性。 一、哈夫曼树基础概念 1. **路径和路径长度**：在一棵树中，从根节点到叶子节点的路径被称为路径，路径上的分支数即为路径...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

繁星蓝雨

如果觉得文章不错，可以请喝咖啡

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值