数据结构编程笔记十七：第六章 树和二叉树 赫夫曼树的实现

最新推荐文章于 2023-09-21 00:10:35 发布
最新推荐文章于 2023-09-21 00:10:35 发布
阅读量736 收藏 7
点赞数 1
分类专栏： 学习笔记 文章标签： 数据结构 赫夫曼树 编码 编程 最优二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014576141/article/details/77610902
版权

上次我们介绍了线索二叉树的实现，这次介绍树这一章的最后一个程序——赫夫曼树的实现。

还是老规矩：

程序在码云上可以下载。
地址：https://git.oschina.net/601345138/DataStructureCLanguage.git

赫夫曼树设计的初衷是为了提高电报传输的效率，缩短字符的编码长度。利用赫夫曼树可以构造一种不等长的二进制编码，并且构造所得的赫夫曼编码是一种最优前缀编码，使所传电文的总长度最短。

书上P148页有一个这样的例子：
例：已知某系统在通讯联络中只可能出现八种字符A,B,C,D,E,F,G,H, 其概率分别为:
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=2n-1=15。

赫夫曼树：
这里写图片描述

赫夫曼编码: 0110, 10, 1110, 1111, 110, 00, 0111, 010

赫夫曼树的程序如下：

//>>>>>>>>>>>>>>>>>>>>>>>>>引入头文件<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

#include <stdio.h>       //使用了标准库函数  
#include <stdlib.h>      //使用了动态内存分配函数 
#include <string.h>      //使用了字符串处理函数strcpy 

//>>>>>>>>>>>>>>>>>>>>>>>自定义符号常量<<<<<<<<<<<<<<<<<<<<<<<<<<<<< 

#define OVERFLOW -2          //内存溢出错误常量
#define OK 1                 //表示操作正确的常量 
#define ERROR 0              //表示操作错误的常量

//>>>>>>>>>>>>>>>>>>>>>>>自定义数据类型<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

typedef int  Status;      //用typedef给int起个别名，也便于程序的维护 

//----------------赫夫曼树和赫夫曼编码的存储表示------------------- 
typedef struct{
    unsigned int weight;                  //权值
    unsigned int parent, lchild, rchild;  //双亲，左孩子，右孩子 
}HTNode, * HuffmanTree;            //动态分配数组存储赫夫曼树 

typedef char * * HuffmanCode;     //动态分配数组存储赫夫曼编码表 

//----------------------赫夫曼树的主要操作--------------------------

/*
    函数：min
    参数：HuffmanTree HT 指向赫夫曼树结点的指针
          int i 在HT中查找最小值范围的上限（就是个下标） 
    返回值：被选中的权值最小的结点在HT中的下标 
    作用：从HT指示的赫夫曼树的[1..i-1]范围的结点中选出权值最小的结点。
          该函数被Select函数调用 
*/
int min(HuffmanTree HT, int i){

    //j是临时变量，flag记录了权值最小的结点在HT中的下标 
    int j, flag = 1;

    //设置k的值为一个结点的权值极难超越的最大值
    unsigned int k = 10000;

    //从赫夫曼树的所有结点中选出权值最小的结点并记录其在HT中的下标 
    for(j = 1; j <= i; j++){

        //k保存了目前最小的权值，若有结点的权值比k小，更新k值为该结点权值
        //flag保存了目前最小权值，若发现比k更小的权值，更新flag为该结点下标 
        //HT[j].parent == 0 说明该结点还没有被选中过（选过的结点不能再选） 
        if(HT[j].weight < k && HT[j].parent == 0){
            k = HT[j].weight, flag = j;
        }//if
    }//for

    //循环结束后，k保存了赫夫曼树所有备选结点中权值的最小值
    //flag保存了权值最小结点在HT中的下标 
    //此时被选中的权值最小的结点就是HT[flag] 

    //修改被选中结点的双亲，防止这个结点再次被选中 
    //调用一次Select函数会调用两次min函数，假设此次是第一次调用min函数，
    //如果不设置双亲的值为1则后续的一次min函数调用还会重复选中这个结点，
    //那生成的赫夫曼树结果就不对了。 
    HT[flag].parent = 1;

    //返回被选中的权值最小的结点在HT中的下标 
    return flag;
}//min

/*
    函数：Select
    参数：HuffmanTree HT 指向赫夫曼树结点的指针
          int i 在HT中查找最小值范围的上限（就是个下标）
          int &s1 带回找出的第一个权值最小结点在HT中的下标
          int &s2 带回找出的第二个权值最小结点在HT中的下标，且s2 >= s1 
    返回值：无
    作用：在HT[1..i-1]选择parent为0且weight最小的两个结点，
          其序号分别为是s1和s2。 
*/
void Select(HuffmanTree HT, int i, int &s1, int &s2){  //选择函数 

    //临时变量j 
    int j;

    //找出第一个权值最小结点在HT中的下标s1 
    s1 = min(HT, i);

    //找出第二个权值最小结点在HT中的下标s2 
    s2 = min(HT, i);

    //若s1和s2位置不对，则对调一下 
    if(s1 > s2){
        j = s1;
        s1 = s2;
        s2 = j;
    }//if
}//Select 

/*
    函数：PrintHT
    参数：HuffmanTree HT 指向赫夫曼树结点的指针
          int n 权值个数 
    返回值：无
    作用：按照书上P149页格式打印HT的存储结构表 
*/
void PrintHT(HuffmanTree HT, int n){

    //n个字符构造的赫夫曼树共有2*n-1个结点
    int m = 2 * n - 1;

    printf("\n+-------------------------------------------------------------+\n");
    printf("|                         赫夫曼树HT的存储结构                |\n");
    printf("+----------+----------+----------+--------------+-------------+\n");
    printf("| 结点编号 |  weight  |  parent  |  leftchild   |  rightchild |\n");
    printf("+----------+----------+----------+--------------+-------------+\n");
    for(int i = 1; i <= m; i++){
        printf("|   %4d   |   %4d   |   %4d   |     %4d     |    %4d     |\n",
                i, HT[i].weight, HT[i].parent, HT[i].lchild, HT[i].rchild);
        printf("+----------+----------+----------+--------------+-------------+\n");
    }//for 
}//PrintHT

/*
    函数：HuffmanCoding
    参数：HuffmanTree &HT 赫夫曼树的引用
          HuffmanCode &HC 根据赫夫曼树构造的赫夫曼编码
          int *w 指向放n个字符的权值内存区域的指针 
          int n  有n个字符要生成赫夫曼编码 
    返回值：状态码，操作成功返回OK，否则返回ERROR 
    作用：w存放n个字符的权值（均>0），构造赫夫曼树 HT，
          并求出n个字符的赫夫曼编码 HC 
*/
Status HuffmanCoding(HuffmanTree &HT, HuffmanCode &HC, int *w, int n){

    //s1和s2保存选出的两个权值最小的结点在HT中的下标
    //i是临时变量，循环用
    //start指示了赫夫曼编码结束符在cd指示的求编码的临时空间中的位置 
    //f是s1和s2的双亲在HT中的下标 
    int s1, s2, i, start, f;

    //cd指向动态分配的求编码的临时空间 
    char *cd;

    printf("->构造赫夫曼树过程分析:\n"); 

    //p是工作指针，指向赫夫曼树中的结点 
    HuffmanTree p = NULL;

    //检查权值个数参数n是否合法 
    if(n <= 1) {
        return ERROR;
    }//if

    //n个字符构造的赫夫曼树共有m = 2*n-1个结点
    int m = 2 * n - 1; 
    printf("->待构造的赫夫曼树共有2 ×%d - 1 = %d个结点\n", n, m);

    //申请赫夫曼树结点占用的内存空间,0号单元不用 
    if(!(HT = (HuffmanTree)malloc((m + 1) * sizeof(HTNode)))) {
        exit(OVERFLOW);
    }//if 
    printf("->赫夫曼树共分配了%d个结点空间，其中包含一个不用的0号单元\n", m + 1);

    //初始化HT内部各个分量的值 
    printf("->初始化所有叶子节点的权值，父亲和孩子：\n");
    for(p = HT + 1, i = 1; i <= n; ++i, ++p, ++w){

        //填入用户输入的权值 
        p->weight = *w;

        //双亲初始值为0，表示此结点还没有被选择最小的算法选择过 
        p->parent = 0;

        //左右孩子初始化为0，表示空 
        p->lchild = 0;
        p->rchild = 0;

        //打印初始化结果（书上没有） 
        printf("->初始化叶子结点%d的权值为%d,父亲为%d,左右孩子分别为%d,%d\n", 
            i, p->weight, p->parent, p->lchild, p->rchild); 
    }//for

    //赫夫曼树生成过程中会循环选择两个权值最小的的结点求出权值之和生成一个新的结点
    //然后把新生成的结点插入HT中。所以HT除了权值（叶子结点）还需要预留一些空间
    //存储生成的非叶子结点。 这些结点暂时还没生成，所以暂时将它们的各个分量初值置零。 
    for(; i <= m; i++, p++){
        p->weight = 0;
        p->parent = 0;
        p->lchild = 0;
        p->rchild = 0;
    }//for

    //打印初始的赫夫曼树存储结构HT内部的情况，以便和后续的生成过程进行比较 
    PrintHT(HT,n); 

    //暂停程序，让用户看到当前输出的HT 
    system("pause");

    //开始构造赫夫曼树 
    printf("->开始利用输入的权值构造一棵赫夫曼树：\n"); 
    //n是输入权值的个数，也是叶子结点的个数。刚初始化完的赫夫曼树HT
    //中，0号单元不用，从1-n存放的是输入的权值（叶子结点，暂时没双亲）
    //所以我们生成新结点要从HT的第n+1个位置开始到m结束 
    for(i = n + 1; i <= m; ++i){  

        //在HT[1..i-1]选择parent为0且weight最小的两个结点，其序号分别为是s1和s2 
        //注意：每次选择的时候要把新生成的结点也算进来。 
        Select(HT, i - 1, s1, s2);
        printf("->选择从1-%d的最小权值的结点%d[%d]和%d[%d]\n", 
            i - 1, s1, HT[s1].weight, s2, HT[s2].weight);

        //选出的两个权值最小的结点的双亲就是即将生成的结点 
        HT[s1].parent = i;
        HT[s2].parent = i;

        //即将生成的结点左孩子是s1，右孩子是s2，
        //因为s1比s2先选，所以s1总是小于等于s2 
        HT[i].lchild = s1;
        HT[i].rchild = s2;

        //即将生成结点的权值就是两个权值最小的结点的权值之和 
        HT[i].weight = HT[s1].weight + HT[s2].weight;

        //打印初始化结果 
        printf("->初始化非叶子结点%d的权值为左右孩子%d,%d的权值之和%d+%d=%d,左右孩子的父亲为%d\n",
             i, s1, s2, HT[s1].weight, HT[s2].weight, HT[i].weight, HT[s1].parent);
        PrintHT(HT, n);

        //暂停程序执行，让用户动态观察HT存储结构内数据的变化过程 
        system("pause");
    }//for

    //构造操作完成 
    printf("->赫夫曼树构造完成\n");


    //---------------从叶子到根逆向求每个字符的赫夫曼编码------------------
    printf("->根据构造好的赫夫曼树从叶子到根求每个字符的赫夫曼编码：\n");

    //申请赫夫曼编码占用的内存空间 
    if(!(HC = (HuffmanCode)malloc((n + 1) * sizeof(char *)))) { 
        exit(OVERFLOW);
    }//if

    //申请求编码的工作空间 
    if(!(cd = (char *)malloc(n * sizeof(char)))) {
        exit(OVERFLOW);
    }//if 

    //编码结束符——字符串结束标志\0 
    cd[n-1] = '\0';

    //逐个字符求赫夫曼编码 
    for(int i = 1; i <= n; ++i){

        //编码结束符位置 
        start = n - 1;

        //从叶子到根逆向求编码 
        for(int c = i, f = HT[i].parent; f != 0; c = f, f = HT[f].parent) {

            //叶子结点根结点的左孩子 
            if(HT[f].lchild == c) {

                //生成编码0 
                cd[--start] = '0';
            }//if
            else { //叶子结点根结点的右孩子 

                //生成编码1 
                cd[--start] = '1';
            }//else
        }//for

        //申请一段内存空间用于保存生成的赫夫曼编码 
        if(!(HC[i] = (char *)malloc((n - start) * sizeof(char)))) { 
            exit(OVERFLOW);
        }//if

        //将临时工作空间cd中拷贝计算出的赫夫曼编码到HC对应的位置上 
        strcpy(HC[i], &cd[start]);

        //打印生成的赫夫曼编码 
        printf("->叶子节点%d的赫夫曼编码为:%s\n", i, HC[i]);
    }//for

    //释放临时工作空间cd 
    free(cd);

    //操作成功 
    return OK;
}//HuffmanCoding 

//-----------------------主函数------------------------ 
int main(int argc, char *argv[]) {
    printf("---------------------------------赫夫曼树引用版---------------------------------\n");

    //指向赫夫曼树的指针 
    HuffmanTree HT;

    //指向存储赫夫曼编码存储区域的指针 
    HuffmanCode HC;

    //n是输入权值的个数
    //w是指向权值存储区域的指针 
    int *w, n;
    printf("->请输入所要建立赫夫曼树权值的个数（>1）：");
    scanf("%d", &n);

    //根据输入权值的个数申请保存权值的存储空间 
    if(!(w =  (int *)malloc(n * sizeof(int)))) { 
        exit(OVERFLOW);
    }//if

    //从键盘接收n个权值并保存到w指示的内存区域中 
    printf("->请依次输入%d个权值（整型，用空格隔开）：\n",n);
    for(int i = 0; i <= n - 1; i++) {
        scanf("%d", w + i);
    }//for

    //调用算法得出赫夫曼编码 
    HuffmanCoding(HT, HC, w, n);

    //输出赫夫曼编码 
    printf("->您建立的赫夫曼树对应的赫夫曼编码如下：\n");
    for(int i = 1; i <= n; i++) { 
        puts(HC[i]);
    }//for 

    //释放掉存放权值的内存空间 
    free(w);
    w = NULL;

    //释放掉赫夫曼树HT占用的内存空间
    free(HT);
    HT = NULL;

    //释放赫夫曼编码HC占用的内存空间 
    free(HC);
    HC = NULL;

    return 0;
}//main

本程序为动态演示版本，你可以通过观察HT的存储结构中数据的变化以及输出信息理解赫夫曼树建立的过程。
本程序使用的是课本P148页的赫夫曼树（也就是本文例子中的那张图片）作为测试的例子，请自行验证其正确性，下面是测试数据：

    ---------------------------------赫夫曼树引用版---------------------------------
->请输入所要建立赫夫曼树权值的个数（>1）：8
->请依次输入8个权值（整型，用空格隔开）：
5 29 7 8 14 23 3 11
->构造赫夫曼树过程分析:
->待构造的赫夫曼树共有2 ×8 - 1 = 15个结点
->赫夫曼树共分配了16个结点空间，其中包含一个不用的0号单元
->初始化所有叶子节点的权值，父亲和孩子：
->初始化叶子结点1的权值为5,父亲为0,左右孩子分别为0,0
->初始化叶子结点2的权值为29,父亲为0,左右孩子分别为0,0
->初始化叶子结点3的权值为7,父亲为0,左右孩子分别为0,0
->初始化叶子结点4的权值为8,父亲为0,左右孩子分别为0,0
->初始化叶子结点5的权值为14,父亲为0,左右孩子分别为0,0
->初始化叶子结点6的权值为23,父亲为0,左右孩子分别为0,0
->初始化叶子结点7的权值为3,父亲为0,左右孩子分别为0,0
->初始化叶子结点8的权值为11,父亲为0,左右孩子分别为0,0

+-------------------------------------------------------------+
|                         赫夫曼树HT的存储结构                |
+----------+----------+----------+--------------+-------------+
| 结点编号 |  weight  |  parent  |  leftchild   |  rightchild |
+----------+----------+----------+--------------+-------------+
|      1   |      5   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      2   |     29   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      3   |      7   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      4   |      8   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      5   |     14   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      6   |     23   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      7   |      3   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      8   |     11   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      9   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     10   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     11   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     12   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     13   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     14   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     15   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
请按任意键继续. . .
->开始利用输入的权值构造一棵赫夫曼树：
->选择从1-8的最小权值的结点1[5]和7[3]
->初始化非叶子结点9的权值为左右孩子1,7的权值之和5+3=8,左右孩子的父亲为9

+-------------------------------------------------------------+
|                         赫夫曼树HT的存储结构                |
+----------+----------+----------+--------------+-------------+
| 结点编号 |  weight  |  parent  |  leftchild   |  rightchild |
+----------+----------+----------+--------------+-------------+
|      1   |      5   |      9   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      2   |     29   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      3   |      7   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      4   |      8   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      5   |     14   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      6   |     23   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      7   |      3   |      9   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      8   |     11   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      9   |      8   |      0   |        1     |       7     |
+----------+----------+----------+--------------+-------------+
|     10   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     11   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     12   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     13   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     14   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     15   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
请按任意键继续. . .
->选择从1-9的最小权值的结点3[7]和4[8]
->初始化非叶子结点10的权值为左右孩子3,4的权值之和7+8=15,左右孩子的父亲为10

+-------------------------------------------------------------+
|                         赫夫曼树HT的存储结构                |
+----------+----------+----------+--------------+-------------+
| 结点编号 |  weight  |  parent  |  leftchild   |  rightchild |
+----------+----------+----------+--------------+-------------+
|      1   |      5   |      9   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      2   |     29   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      3   |      7   |     10   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      4   |      8   |     10   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      5   |     14   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      6   |     23   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      7   |      3   |      9   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      8   |     11   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      9   |      8   |      0   |        1     |       7     |
+----------+----------+----------+--------------+-------------+
|     10   |     15   |      0   |        3     |       4     |
+----------+----------+----------+--------------+-------------+
|     11   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     12   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     13   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     14   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     15   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
请按任意键继续. . .
->选择从1-10的最小权值的结点8[11]和9[8]
->初始化非叶子结点11的权值为左右孩子8,9的权值之和11+8=19,左右孩子的父亲为11

+-------------------------------------------------------------+
|                         赫夫曼树HT的存储结构                |
+----------+----------+----------+--------------+-------------+
| 结点编号 |  weight  |  parent  |  leftchild   |  rightchild |
+----------+----------+----------+--------------+-------------+
|      1   |      5   |      9   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      2   |     29   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      3   |      7   |     10   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      4   |      8   |     10   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      5   |     14   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      6   |     23   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      7   |      3   |      9   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      8   |     11   |     11   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      9   |      8   |     11   |        1     |       7     |
+----------+----------+----------+--------------+-------------+
|     10   |     15   |      0   |        3     |       4     |
+----------+----------+----------+--------------+-------------+
|     11   |     19   |      0   |        8     |       9     |
+----------+----------+----------+--------------+-------------+
|     12   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     13   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     14   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     15   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
请按任意键继续. . .
->选择从1-11的最小权值的结点5[14]和10[15]
->初始化非叶子结点12的权值为左右孩子5,10的权值之和14+15=29,左右孩子的父亲为12

+-------------------------------------------------------------+
|                         赫夫曼树HT的存储结构                |
+----------+----------+----------+--------------+-------------+
| 结点编号 |  weight  |  parent  |  leftchild   |  rightchild |
+----------+----------+----------+--------------+-------------+
|      1   |      5   |      9   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      2   |     29   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      3   |      7   |     10   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      4   |      8   |     10   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      5   |     14   |     12   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      6   |     23   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      7   |      3   |      9   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      8   |     11   |     11   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      9   |      8   |     11   |        1     |       7     |
+----------+----------+----------+--------------+-------------+
|     10   |     15   |     12   |        3     |       4     |
+----------+----------+----------+--------------+-------------+
|     11   |     19   |      0   |        8     |       9     |
+----------+----------+----------+--------------+-------------+
|     12   |     29   |      0   |        5     |      10     |
+----------+----------+----------+--------------+-------------+
|     13   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     14   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     15   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
请按任意键继续. . .
->选择从1-12的最小权值的结点6[23]和11[19]
->初始化非叶子结点13的权值为左右孩子6,11的权值之和23+19=42,左右孩子的父亲为13

+-------------------------------------------------------------+
|                         赫夫曼树HT的存储结构                |
+----------+----------+----------+--------------+-------------+
| 结点编号 |  weight  |  parent  |  leftchild   |  rightchild |
+----------+----------+----------+--------------+-------------+
|      1   |      5   |      9   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      2   |     29   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      3   |      7   |     10   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      4   |      8   |     10   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      5   |     14   |     12   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      6   |     23   |     13   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      7   |      3   |      9   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      8   |     11   |     11   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      9   |      8   |     11   |        1     |       7     |
+----------+----------+----------+--------------+-------------+
|     10   |     15   |     12   |        3     |       4     |
+----------+----------+----------+--------------+-------------+
|     11   |     19   |     13   |        8     |       9     |
+----------+----------+----------+--------------+-------------+
|     12   |     29   |      0   |        5     |      10     |
+----------+----------+----------+--------------+-------------+
|     13   |     42   |      0   |        6     |      11     |
+----------+----------+----------+--------------+-------------+
|     14   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|     15   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
请按任意键继续. . .
->选择从1-13的最小权值的结点2[29]和12[29]
->初始化非叶子结点14的权值为左右孩子2,12的权值之和29+29=58,左右孩子的父亲为14

+-------------------------------------------------------------+
|                         赫夫曼树HT的存储结构                |
+----------+----------+----------+--------------+-------------+
| 结点编号 |  weight  |  parent  |  leftchild   |  rightchild |
+----------+----------+----------+--------------+-------------+
|      1   |      5   |      9   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      2   |     29   |     14   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      3   |      7   |     10   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      4   |      8   |     10   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      5   |     14   |     12   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      6   |     23   |     13   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      7   |      3   |      9   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      8   |     11   |     11   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      9   |      8   |     11   |        1     |       7     |
+----------+----------+----------+--------------+-------------+
|     10   |     15   |     12   |        3     |       4     |
+----------+----------+----------+--------------+-------------+
|     11   |     19   |     13   |        8     |       9     |
+----------+----------+----------+--------------+-------------+
|     12   |     29   |     14   |        5     |      10     |
+----------+----------+----------+--------------+-------------+
|     13   |     42   |      0   |        6     |      11     |
+----------+----------+----------+--------------+-------------+
|     14   |     58   |      0   |        2     |      12     |
+----------+----------+----------+--------------+-------------+
|     15   |      0   |      0   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
请按任意键继续. . .
->选择从1-14的最小权值的结点13[42]和14[58]
->初始化非叶子结点15的权值为左右孩子13,14的权值之和42+58=100,左右孩子的父亲为15

+-------------------------------------------------------------+
|                         赫夫曼树HT的存储结构                |
+----------+----------+----------+--------------+-------------+
| 结点编号 |  weight  |  parent  |  leftchild   |  rightchild |
+----------+----------+----------+--------------+-------------+
|      1   |      5   |      9   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      2   |     29   |     14   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      3   |      7   |     10   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      4   |      8   |     10   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      5   |     14   |     12   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      6   |     23   |     13   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      7   |      3   |      9   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      8   |     11   |     11   |        0     |       0     |
+----------+----------+----------+--------------+-------------+
|      9   |      8   |     11   |        1     |       7     |
+----------+----------+----------+--------------+-------------+
|     10   |     15   |     12   |        3     |       4     |
+----------+----------+----------+--------------+-------------+
|     11   |     19   |     13   |        8     |       9     |
+----------+----------+----------+--------------+-------------+
|     12   |     29   |     14   |        5     |      10     |
+----------+----------+----------+--------------+-------------+
|     13   |     42   |     15   |        6     |      11     |
+----------+----------+----------+--------------+-------------+
|     14   |     58   |     15   |        2     |      12     |
+----------+----------+----------+--------------+-------------+
|     15   |    100   |      0   |       13     |      14     |
+----------+----------+----------+--------------+-------------+
请按任意键继续. . .
->赫夫曼树构造完成
->根据构造好的赫夫曼树从叶子到根求每个字符的赫夫曼编码：
->叶子节点1的赫夫曼编码为:0110
->叶子节点2的赫夫曼编码为:10
->叶子节点3的赫夫曼编码为:1110
->叶子节点4的赫夫曼编码为:1111
->叶子节点5的赫夫曼编码为:110
->叶子节点6的赫夫曼编码为:00
->叶子节点7的赫夫曼编码为:0111
->叶子节点8的赫夫曼编码为:010
->您建立的赫夫曼树对应的赫夫曼编码如下：
0110
10
1110
1111
110
00
0111
010

--------------------------------
Process exited with return value 0
Press any key to continue . . .

下次的文章会介绍基于邻接矩阵存储结构的图的各种基本操作的实现以及图的深度优先遍历、广度优先遍历算法的实现。感谢大家一直以来的支持和鼓励！希望大家继续关注我的博客，也希望我的文章能帮助大家更好的理解书上的算法。再见！

逗比驾到
关注
专栏目录
数据结构与算法学习笔记 之 程杰《大话数据结构》数据结构篇
MuscleMonk的博客
07-26 1084
数据结构与算法学习笔记 之 程杰《大话数据结构》 第一章 数据结构绪论 数据项：数据不可分割的最小单位。在数据结构课程中，把数据项定义为最小单位，有助于我们更好地解决问题。但是真正讨论问题时，数据元素才是数据结构中建立数据模型的着眼点。 数据对象：是性质相同的数据元素的集合，是数据的子集。其中，性质相同是指数据元素具有相同数量和类型的数据项。 结构：各个组成部分相互搭配和排列的方式。 数据结构：相互之间存在一种或多种特定关系的数据元素的集合。 数据类型：是指一组性质相同的值的集合及定义在此集合上的一些操作
Java数据结构和算法笔记总结
笔记别偷看
11-19 1440
第 1章 数据结构和算法概述 数据结构和算法的关系 数据 data 结构(structure)是一门研究组织数据方式的学科，有了编程语言也就有了数据结构.学好数据结构可以编写出更加漂亮,更加有效率的代码。 要学习好数据结构就要多多考虑如何将生活中遇到的问题,用程序去实现解决. 程序 = 数据结构 + 算法 数据结构是算法的基础, 换言之，想要学好算法，需要把数据结构学到位。 数据结构和算法的应用 修路问题 => 最小生成树(加权值)【数据结构】+ 普利姆算法 最短路径问题 => 图+弗洛
二叉树 程序设计 课题研究的目的和意义
06-20
程序设计 二叉排序树 整个程序和流程图等 课题研究的目的和意义 可行性论证 课题总体设计方案 模块划分 数据结构 若干关键技术及设计结果 、结果分析 心得体会 参考文献
赫夫曼树
li6322511的专栏
12-18 972
【摘要】赫夫曼树，又称“最优树”，是一种带权路径最短的树。赫夫曼树的提出，不仅具有极大的理论价值，而且它的实际应用也十分广泛。本文主要针对赫夫曼树的相关概念的理解，赫夫曼树的构造以及赫夫曼编码的应用做简单阐述。 【关键词】赫夫曼树；构造；编码 【正文】 一 赫夫曼树相关概念的理解 赫夫曼树，既然是一种带权路径长度最短的树，这里就牵扯到“路径”、“路径长度”、“树的路径长度”
哈夫曼编码的原理与实现
超纯的小白兔
09-29 2097
我们设置一个结构数组 HuffNode 保存哈夫曼树中各结点的信息。根据二叉树的性质可知，具有n个叶子结点的哈夫曼树共有 2n-1 个结点，所以数组 HuffNode 的大小设置为 2n-1 。HuffNode 结构中有 weight, lchild, rchild 和 parent 域。其中，weight 域保存结点的权值, lchild 和 rchild 分别保存该结点的左、右孩子的结点在数组
哈夫曼树
缱绻的西格玛
08-18 921
哈夫曼树是所有树之中最优秀的品种之一，是带权路径长度最短的最小二叉树，比之前的数据结构要多考验逻辑一点。该程序可以实现哈夫曼树的编码还有解码，代码如下所示： lcwHuffmantree.c主要是哈夫曼树的基本操作函数//start from the very beginning,and to create greatness //@author: Chuangwei Lin //@E-mail：
求赫夫曼编码。实现算法6.12的程序
但行好事，莫问前程
04-19 629
最优二叉树（赫夫曼编码） 最优二叉树是带权路径长度最短的二叉树。根据结点的个数、权值的不同，最优二叉树的形状也各不相同。下图是 3 棵最优二叉树的例子。它们的共同特点是：带权值的结点都是叶子结点。权值越小的结点，其到根结点的路径越长。 最优二叉树的左右子树是可以互换的，因为这不影响树的带权路径长度。 当结点的权值差别大到一定程度，最优二叉树就形成了如图(...
哈夫曼树——学习笔记
Redmancy_的博客
04-09 2077
@TOC 了解哈夫曼树 先看一个例题： 将学生的百分制成绩转换为五分制成绩（编程），90-100:A 80-90:B 70-80:C 60-70: D <60:E 代码如下： if(score<60) grade=='E'; else if(score<70) grade=='D'; else if(score<80) ...
数据结构期末复习
weixin_52277317的博客
01-01 1966
zzulier的数据结构期末复习 数据结构期末复习**zzulier的数据结构期末复习**第一章 绪论1.基本概念和术语2.算法和算法分析 第一章 绪论 1.基本概念和术语 （1）数据结构：是互相之间存在一种或多种特定关系的数据元素的集合。 （2）数据、数据元素、数据对象、数据项概念辨析： ①首次需要明确的是：数据>数据元素>数据项 （例：学生表>个人信息>某一信息） ②关系图：若将数据看做一个集合，那么有以下关系： （3）数据结构包含：逻辑结构&存储（物理）结构 逻辑结
chapter5. Java数据结构与java算法
weixin_56137667的博客
08-04 736
一、数据结构和算法概述 数据结构包括：线性结构和非线性结构。 1线性结构 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。 一对一e.g. a[0] = 3; 线性结构有两种不同的存储结构，即顺序存储结构(数组)和链式存储结构(链表)。 顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息（链表可以充分利用碎片内存） 线性结构常见的有：数组、队列、链表和栈，后面我们会详细讲解.
数据结构C语言编程—二叉树哈弗曼编码
qq_42295125的博客
05-10 247
#include<stdio.h> #include<malloc.h> #include<string.h> #include<windows.h> #define M 8 #define MAX 200 typedef struct { int data; int pa,lc,rc; }JD; typedef struct HuffmanCode { char data1; struct HuffmanCode *next; }*code; code te
[数据结构]哈夫曼树和哈夫曼编码
jiaqi0806的博客
06-29 686
哈夫曼树 基本概念 哈夫曼树即最优二叉树，指一类带权路径长度最短的树，其中每个结点的带权路径长度为，结点到树根之间的路径长度与结点权值的乘积。树的带权路径长度即为所有结点之和，写作： WPL=Σ wiLi 带权路径长度WPL最小的二叉树即为哈夫曼树。 哈夫曼树的构造 算法描述： 1、根据给定的n个权值{w1，w2，…，wn}构成n棵二叉树的集合F={T1,T2,…,Tn}，其中Ti中只有一个权值为wi的根节点，左右子树均为空。 2、在F中选取两棵根节点的权值最小的树作为左、右子树，构造一棵新的二叉树，且让新
哈夫曼树的构造_案例
tango_wolf的博客
12-31 4752
哈夫曼树的构造算法： 构造树林全是根，选用两小造新树。 删除两小添新人，重复23建新根。 例题：已知某系统在通讯联络种只可能出现8种字符设为 {A,B,C,D,E,F,G,H}，其频率分别为0.05，0.29，0.07，0.08，0.14，0.23，0.03，0.11，试构造一棵哈夫曼树并设计其哈夫曼编码（构造哈夫曼树，设计哈夫曼编码） 注意1：哈夫曼树要求树中左孩子结点的权值不大于右孩子结点的权值；编码原则：左分支为0，右分支为1） 注意2：设权w={5，29，7，8，14，23，3，11}，n=8，m=
赫夫曼树(最优二叉树),又称最优树,是一“类”(并不一定是一棵)带权路径长度最短的树.
Vigor's Blog
12-23 1万+
例:已知某系统在通信联络中只可能出现八种字符，其概率分别为   0.05，0.29，0.07，0.08，0.14，0.23，0.03，0.11  试设计赫夫曼编码。1.排序   A      B      C      D　　　E      F      G      H  0.03 , 0.05 , 0.07 , 0.08 , 0.11 , 0.14 , 0.23 , 0.292.      
哈夫曼存储的初态和终态
最新发布
m0_47111148的博客
09-21 772
【哈夫曼树3-创建-一行代码一解释+表格-哔哩哔哩】 https://b23.tv/VherCS6。这是我发现的一个很详细的讲解视频。
霍夫码编码（一种不等长，非前缀编码方式）
hanhan的博客
04-30 6170
霍夫曼编码是一种不等长非前缀编码方式，于1951年由MIT的霍夫曼提出。 用于对一串数字/符号编码获取最短的结果，获取最大的压缩效率。 特点：不等长、非前缀 等长式编码 等长编码，意思是对出现的元素采用相同位数的序号进行标定，如下列所示：(这里我们采用三位) 假设有这样一串数据： 编码后的数据量：12 x 3bit=36bit. 思考：对5个数编码没必要每个数是同样的长度，只要五个字符对应的五...
湖南科技大学—数据结构（C语言版）算法6.12__huffman编码
hnust_xiehonghao的专栏
08-30 3780
问题 I: 数据结构（C语言版）算法6.12__huffman编码 时间限制: 1 Sec  内存限制: 128 MB 提交: 20  解决: 12 [提交][状态][讨论版] 题目描述 w存放n个字符的权值(权值均是大于0的正整数)，构造赫夫曼树HT，并求出n个字符的赫夫曼编码HC。其它未明示之处请参见教材P147页上的相关文字及算法描述。 输入 先输入权值的个数n（n
记信息论与编码之课设-哈夫曼编码
GG_Killer的博客
11-26 5687
哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式，  夫曼编码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长度最短的码字，有时称之为最佳编码，一般就叫做Huffman编码（有时也称为霍夫曼编码）    首先，将符号按照概率由大到小排队，编码时，从最小概率的两个符号开始，可选其中一个支 路为0
四种基本存储结构
热门推荐
qq_44818849的博客
11-22 1万+
数据的四种存储结构 数据的存储结构：1.顺序存储、2.链接存储、3.索引存储、4.散列存储。 1.顺序存储 此存储方式就是将逻辑相邻的元素存储在物理位置也是相邻的存储单元。常见的实现方式是数组来表示。 优点 可以随机访问存储单元，时间复杂度为O(1) 缺点 增加或者删除元素需要移动元素 2.链接存储 这种存储方式不需要将逻辑相邻的元素也存储在物理位置也相邻，物理位置可以不是连续。节点间的逻辑关系通过指针字段链接 优点 增加或者删除节点方便 缺点 存储结构的存储密度小，每个节点都有指针域 不能随机访问存储单元
数据结构精讲：第六章 树与二叉树的概念与操作
"杭州电子科技大学 数据结构 C语言 PPT 课件 第六章，主要讲解了树和二叉树的概念、基本术语以及相关操作。" 在数据结构领域，树是一种非常重要的非线性数据结构，它能有效地表示数据之间的层次关系。在第六章中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值