哈夫曼树的基本构建与操作

看到的讲解huffman树的一篇比较好懂的博客

出处:http://blog.csdn.net/wtfmonking/article/details/17150499#

1、基本概念


a、路径和路径长度

若在一棵树中存在着一个结点序列 k1,k2,……,kj, 使得 kiki+1 的双亲(1<=i<j),则称此结点序列是从 k1 到 kj 的路径。

从 k1 到 kj 所经过的分支数称为这两点之间的路径长度,它等于路径上的结点数减1.


b、结点的权和带权路径长度

在许多应用中,常常将树中的结点赋予一个有着某种意义的实数,我们称此实数为该结点的权,(如下面一个树中的蓝色数字表示结点的权)

结点的带权路径长度规定为从树根结点到该结点之间的路径长度与该结点上权的乘积。


c、树的带权路径长度

树的带权路径长度定义为树中所有叶子结点的带权路径长度之和,公式为:


其中,n表示叶子结点的数目,wi 和 li 分别表示叶子结点 ki 的权值和树根结点到 ki 之间的路径长度。

如下图中树的带权路径长度 WPL = 9 x 2 + 12 x 2 + 15 x 2 + 6 x 3 + 3 x 4 + 5 x 4  =  122



d、哈夫曼树

哈夫曼树又称最优二叉树。它是 n 个带权叶子结点构成的所有二叉树中,带权路径长度 WPL 最小的二叉树。

如下图为一哈夫曼树示意图。


2、构造哈夫曼树


假设有n个权值,则构造出的哈夫曼树有n个叶子结点。 n个权值分别设为 w1、w2、…、wn,则哈夫曼树的构造规则为:


(1) 将w1、w2、…,wn看成是有n 棵树的森林(每棵树仅有一个结点);


(2) 在森林中选出两个根结点的权值最小的树合并,作为一棵新树的左、右子树,且新树的根结点权值为其左、右子树根结点权值之和;


(3)从森林中删除选取的两棵树,并将新树加入森林;


(4)重复(2)、(3)步,直到森林中只剩一棵树为止,该树即为所求得的哈夫曼树。


 如:对 下图中的六个带权叶子结点来构造一棵哈夫曼树,步骤如下:


注意:为了使得到的哈夫曼树的结构尽量唯一,通常规定生成的哈夫曼树中每个结点的左子树根结点的权小于等于右子树根结点的权。


具体算法如下:

  1. //2、根据数组 a 中 n 个权值建立一棵哈夫曼树,返回树根指针  
  2. struct BTreeNode* CreateHuffman(ElemType a[], int n)  
  3. {  
  4.     int i, j;  
  5.     struct BTreeNode **b, *q;  
  6.     b = malloc(n*sizeof(struct BTreeNode));  
  7.     for (i = 0; i < n; i++) //初始化b指针数组,使每个指针元素指向a数组中对应的元素结点  
  8.     {  
  9.         b[i] = malloc(sizeof(struct BTreeNode));  
  10.         b[i]->data = a[i];  
  11.         b[i]->left = b[i]->right = NULL;  
  12.     }  
  13.     for (i = 1; i < n; i++)//进行 n-1 次循环建立哈夫曼树  
  14.     {  
  15.         //k1表示森林中具有最小权值的树根结点的下标,k2为次最小的下标  
  16.         int k1 = -1, k2;  
  17.         for (j = 0; j < n; j++)//让k1初始指向森林中第一棵树,k2指向第二棵  
  18.         {  
  19.             if (b[j] != NULL && k1 == -1)  
  20.             {  
  21.                 k1 = j;  
  22.                 continue;  
  23.             }  
  24.             if (b[j] != NULL)  
  25.             {  
  26.                 k2 = j;  
  27.                 break;  
  28.             }  
  29.         }  
  30.         for (j = k2; j < n; j++)//从当前森林中求出最小权值树和次最小  
  31.         {  
  32.             if (b[j] != NULL)  
  33.             {  
  34.                 if (b[j]->data < b[k1]->data)  
  35.                 {  
  36.                     k2 = k1;  
  37.                     k1 = j;  
  38.                 }  
  39.                 else if (b[j]->data < b[k2]->data)  
  40.                     k2 = j;  
  41.             }  
  42.         }  
  43.         //由最小权值树和次最小权值树建立一棵新树,q指向树根结点  
  44.         q = malloc(sizeof(struct BTreeNode));  
  45.         q->data = b[k1]->data + b[k2]->data;  
  46.         q->left = b[k1];  
  47.         q->right = b[k2];  
  48.   
  49.         b[k1] = q;//将指向新树的指针赋给b指针数组中k1位置  
  50.         b[k2] = NULL;//k2位置为空  
  51.     }  
  52.     free(b); //删除动态建立的数组b  
  53.     return q; //返回整个哈夫曼树的树根指针  
  54. }  

3、哈夫曼编码

在电报通信中,电文是以二进制的0、1序列传送的,每个字符对应一个二进制编码,为了缩短电文的总长度,采用不等长编码方式,构造哈夫曼树,

将每个字符的出现频率作为字符结点的权值赋予叶子结点,每个分支结点的左右分支分别用0和1编码,从树根结点到每个叶子结点的路径上

所经分支的0、1编码序列等于该叶子结点的二进制编码。如上文所示的哈夫曼编码如下:

a 的编码为:00

b 的编码为:01

c 的编码为:100

d 的编码为:1010

e 的编码为:1011

f 的编码为:11


4、哈夫曼树的操作运算


以上文的哈夫曼树作为具体实例,用详细的程序展示哈夫曼树的操作运算

  1. #include<stdio.h>  
  2. #include<stdlib.h>  
  3. typedef int ElemType;  
  4. struct BTreeNode  
  5. {  
  6.     ElemType data;  
  7.     struct BTreeNode* left;  
  8.     struct BTreeNode* right;  
  9. };  
  10.   
  11. //1、输出二叉树,可在前序遍历的基础上修改。采用广义表格式,元素类型为int  
  12. void PrintBTree_int(struct BTreeNode* BT)  
  13. {  
  14.     if (BT != NULL)  
  15.     {  
  16.         printf("%d", BT->data); //输出根结点的值  
  17.         if (BT->left != NULL || BT->right != NULL)  
  18.         {  
  19.             printf("(");  
  20.             PrintBTree_int(BT->left); //输出左子树  
  21.             if (BT->right != NULL)  
  22.                 printf(",");  
  23.             PrintBTree_int(BT->right); //输出右子树  
  24.             printf(")");  
  25.         }  
  26.     }  
  27. }  
  28.   
  29. //2、根据数组 a 中 n 个权值建立一棵哈夫曼树,返回树根指针  
  30. struct BTreeNode* CreateHuffman(ElemType a[], int n)  
  31. {  
  32.     int i, j;  
  33.     struct BTreeNode **b, *q;  
  34.     b = malloc(n*sizeof(struct BTreeNode));  
  35.     for (i = 0; i < n; i++) //初始化b指针数组,使每个指针元素指向a数组中对应的元素结点  
  36.     {  
  37.         b[i] = malloc(sizeof(struct BTreeNode));  
  38.         b[i]->data = a[i];  
  39.         b[i]->left = b[i]->right = NULL;  
  40.     }  
  41.     for (i = 1; i < n; i++)//进行 n-1 次循环建立哈夫曼树  
  42.     {  
  43.         //k1表示森林中具有最小权值的树根结点的下标,k2为次最小的下标  
  44.         int k1 = -1, k2;  
  45.         for (j = 0; j < n; j++)//让k1初始指向森林中第一棵树,k2指向第二棵  
  46.         {  
  47.             if (b[j] != NULL && k1 == -1)  
  48.             {  
  49.                 k1 = j;  
  50.                 continue;  
  51.             }  
  52.             if (b[j] != NULL)  
  53.             {  
  54.                 k2 = j;  
  55.                 break;  
  56.             }  
  57.         }  
  58.         for (j = k2; j < n; j++)//从当前森林中求出最小权值树和次最小  
  59.         {  
  60.             if (b[j] != NULL)  
  61.             {  
  62.                 if (b[j]->data < b[k1]->data)  
  63.                 {  
  64.                     k2 = k1;  
  65.                     k1 = j;  
  66.                 }  
  67.                 else if (b[j]->data < b[k2]->data)  
  68.                     k2 = j;  
  69.             }  
  70.         }  
  71.         //由最小权值树和次最小权值树建立一棵新树,q指向树根结点  
  72.         q = malloc(sizeof(struct BTreeNode));  
  73.         q->data = b[k1]->data + b[k2]->data;  
  74.         q->left = b[k1];  
  75.         q->right = b[k2];  
  76.   
  77.         b[k1] = q;//将指向新树的指针赋给b指针数组中k1位置  
  78.         b[k2] = NULL;//k2位置为空  
  79.     }  
  80.     free(b); //删除动态建立的数组b  
  81.     return q; //返回整个哈夫曼树的树根指针  
  82. }  
  83.   
  84. //3、求哈夫曼树的带权路径长度  
  85. ElemType WeightPathLength(struct BTreeNode* FBT, int len)//len初始为0  
  86. {  
  87.     if (FBT == NULL) //空树返回0  
  88.         return 0;  
  89.     else  
  90.     {  
  91.         if (FBT->left == NULL && FBT->right == NULL)//访问到叶子结点  
  92.             return FBT->data * len;  
  93.         else //访问到非叶子结点,进行递归调用,返回左右子树的带权路径长度之和,len递增  
  94.             return WeightPathLength(FBT->left,len+1)+WeightPathLength(FBT->right,len+1);  
  95.     }  
  96. }  
  97.   
  98. //4、哈夫曼编码(可以根据哈夫曼树带权路径长度的算法基础上进行修改)  
  99. void HuffManCoding(struct BTreeNode* FBT, int len)//len初始值为0  
  100. {  
  101.     static int a[10];//定义静态数组a,保存每个叶子的编码,数组长度至少是树深度减一  
  102.     if (FBT != NULL)//访问到叶子结点时输出其保存在数组a中的0和1序列编码  
  103.     {  
  104.         if (FBT->left == NULL && FBT->right == NULL)  
  105.         {  
  106.             int i;  
  107.             printf("结点权值为%d的编码:", FBT->data);  
  108.             for (i = 0; i < len; i++)  
  109.                 printf("%d", a[i]);  
  110.             printf("\n");  
  111.         }  
  112.         else//访问到非叶子结点时分别向左右子树递归调用,并把分支上的0、1编码保存到数组a  
  113.         {   //的对应元素中,向下深入一层时len值增1  
  114.             a[len] = 0;  
  115.             HuffManCoding(FBT->left, len + 1);  
  116.             a[len] = 1;  
  117.             HuffManCoding(FBT->right, len + 1);  
  118.         }  
  119.     }  
  120. }  
  121.   
  122. //主函数  
  123. void main()  
  124. {  
  125.     int n, i;  
  126.     ElemType* a;  
  127.     struct BTreeNode* fbt;  
  128.     printf("从键盘输入待构造的哈夫曼树中带权叶子结点数n:");  
  129.     while(1)  
  130.     {  
  131.         scanf("%d", &n);  
  132.         if (n > 1)  
  133.             break;  
  134.         else  
  135.             printf("重输n值:");  
  136.     }  
  137.     a = malloc(n*sizeof(ElemType));  
  138.     printf("从键盘输入%d个整数作为权值:", n);  
  139.     for (i = 0; i < n; i++)  
  140.         scanf(" %d", &a[i]);  
  141.     fbt = CreateHuffman(a, n);  
  142.     printf("广义表形式的哈夫曼树:");  
  143.     PrintBTree_int(fbt);  
  144.     printf("\n");  
  145.     printf("哈夫曼树的带权路径长度:");  
  146.     printf("%d\n", WeightPathLength(fbt, 0));  
  147.     printf("树中每个叶子结点的哈夫曼编码:\n");  
  148.     HuffManCoding(fbt, 0);  
  149. }  

运行结果:

  • 31
    点赞
  • 156
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
以下是C语言实现哈夫曼树基本操作代码: //定义哈夫曼树结点 typedef struct HuffmanNode { int weight; //权值 int parent; //父结点下标 int leftChild; //左孩子下标 int rightChild; //右孩子下标 } HuffmanNode, *HuffmanTree; //构建哈夫曼树 void createHuffmanTree(HuffmanTree *tree, int n, int *weight) { if (n <= 1) return; //结点数小于等于1,无法构建哈夫曼树 int m = 2 * n - 1; //哈夫曼树总结点数 *tree = (HuffmanTree) malloc((m + 1) * sizeof(HuffmanNode)); //动态分配数组空间 HuffmanTree p = *tree; for (int i = 1; i <= n; i++, p++, weight++) { p->weight = *weight; p->parent = 0; p->leftChild = 0; p->rightChild = 0; } for (int i = n + 1; i <= m; i++, p++) { p->weight = 0; p->parent = 0; p->leftChild = 0; p->rightChild = 0; } for (int i = n + 1; i <= m; i++) { int s1 = 0, s2 = 0; select(tree, i - 1, &s1, &s2); //选择权值最小的两个结点 (*tree)[s1].parent = i; (*tree)[s2].parent = i; (*tree)[i].leftChild = s1; (*tree)[i].rightChild = s2; (*tree)[i].weight = (*tree)[s1].weight + (*tree)[s2].weight; //合并结点 } } //选择权值最小的两个结点 void select(HuffmanTree tree, int n, int *s1, int *s2) { int min1 = INT_MAX, min2 = INT_MAX; for (int i = 1; i <= n; i++) { if (tree[i].parent == 0) { if (tree[i].weight < min1) { min2 = min1; *s2 = *s1; min1 = tree[i].weight; *s1 = i; } else if (tree[i].weight < min2) { min2 = tree[i].weight; *s2 = i; } } } } //销毁哈夫曼树 void destroyHuffmanTree(HuffmanTree *tree) { free(*tree); *tree = NULL; } //编码 void encode(HuffmanTree tree, int n, char *str, char *code) { for (int i = 0; i < n; i++, str++, code++) { int j = 1; HuffmanTree p = tree + 1; while (p->leftChild != 0 && p->rightChild != 0) { if (*str == '0') { p = tree + p->leftChild; *code++ = '0'; } else { p = tree + p->rightChild; *code++ = '1'; } j++; } *code = '\0'; } } //解码 void decode(HuffmanTree tree, int n, char *code, char *str) { for (int i = 0; i < n; i++, code++, str++) { HuffmanTree p = tree + 1; while (p->leftChild != 0 && p->rightChild != 0) { if (*code == '0') { p = tree + p->leftChild; } else { p = tree + p->rightChild; } code++; } *str = (char) p->weight; } }

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值