哈夫曼编码

最新推荐文章于 2025-10-23 14:07:59 发布

转载最新推荐文章于 2025-10-23 14:07:59 发布 · 910 阅读

编程语言专栏收录该内容

3 篇文章

订阅专栏

哈夫曼(Huffman)树+哈夫曼编码

前天acm实验课，老师教了几种排序，抓的一套题上有一个哈夫曼树的题，正好之前离散数学也讲过哈夫曼树，这里我就结合课本，整理一篇关于哈夫曼树的博客。

主要摘自https://www.cnblogs.com/skywang12345/p/3706821.html感谢大佬

https://www.cnblogs.com/kubixuesheng/p/4397798.html这位大佬举例很好

哈夫曼树的介绍

Huffman Tree，中文名是哈夫曼树或霍夫曼树，它是最优二叉树。

定义：给定n个权值作为n个叶子结点，构造一棵二叉树，若树的带权路径长度达到最小，则这棵树被称为哈夫曼树。这个定义里面涉及到了几个陌生的概念，下面就是一颗哈夫曼树，我们来看图解答。

(01) 路径和路径长度

定义：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。例子：100和80的路径长度是1，50和30的路径长度是2，20和10的路径长度是3。

(02) 结点的权及带权路径长度

定义：若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积。例子：节点20的路径长度是3，它的带权路径长度= 路径长度 * 权 = 3 * 20 = 60。

(03) 树的带权路径长度

定义：树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WPL。例子：示例中，树的WPL= 1*100 + 2*50 + 3*20 + 3*10 = 100 + 100 + 60 + 30 = 290。

比较下面两棵树

上面的两棵树都是以{10, 20, 50, 100}为叶子节点的树。

左边的树WPL=2*10 + 2*20 + 2*50 + 2*100 = 360 右边的树WPL=350

左边的树WPL > 右边的树的WPL。你也可以计算除上面两种示例之外的情况，但实际上右边的树就是{10,20,50,100}对应的哈夫曼树。至此，应该堆哈夫曼树的概念有了一定的了解了，下面看看如何去构造一棵哈夫曼树。

哈夫曼树的图文解析

假设有n个权值，则构造出的哈夫曼树有n个叶子结点。 n个权值分别设为 w₁、w₂、…、w_n，哈夫曼树的构造规则为：

1. 将w₁、w₂、…，w_n看成是有n 棵树的森林(每棵树仅有一个结点)；

2. 在森林中选出根结点的权值最小的两棵树进行合并，作为一棵新树的左、右子树，且新树的根结点权值为其左、右子树根结点权值之和；

3. 从森林中删除选取的两棵树，并将新树加入森林；

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

以{5,6,7,8,15}为例，来构造一棵哈夫曼树。

第1步：创建森林，森林包括5棵树，这5棵树的权值分别是5,6,7,8,15。

第2步：在森林中，选择根节点权值最小的两棵树(5和6)来进行合并，将它们作为一颗新树的左右孩子(谁左谁右无关紧要，这里，我们选择较小的作为左孩子)，并且新树的权值是左右孩子的权值之和。即，新树的权值是11。然后，将"树5"和"树6"从森林中删除，并将新的树(树11)添加到森林中。

第3步：在森林中，选择根节点权值最小的两棵树(7和8)来进行合并。得到的新树的权值是15。然后，将"树7"和"树8"从森林中删除，并将新的树(树15)添加到森林中。

第4步：在森林中，选择根节点权值最小的两棵树(11和15)来进行合并。得到的新树的权值是26。然后，将"树11"和"树15"从森林中删除，并将新的树(树26)添加到森林中。

第5步：在森林中，选择根节点权值最小的两棵树(15和26)来进行合并。得到的新树的权值是41。然后，将"树15"和"树26"从森林中删除，并将新的树(树41)添加到森林中。此时，森林中只有一棵树(树41)。这棵树就是我们需要的哈夫曼树！

哈夫曼树代码：

直接使用了PJQ师姐的代码，之后应该会更新。

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <string.h>
  4 struct node
  5 {
  6     int key;
  7     struct node *l;
  8     struct node *r;
  9 };
 10 typedef struct node *pnode;
 11 int mark[100];
 12 struct node  huffman[100];
 13 void PrintNode(const pnode node)
 14 {
 15     printf("key = %d \n", node->key);
 16 }
 17 void PreOrder(pnode T)
 18 {
 19     if(T)
 20     {
 21         PrintNode(T);
 22         PreOrder(T->l);
 23         PreOrder(T->r);
 24     }
 25 }
 26 void Select(int *mark, struct node *huffman, int size, int *choose)
 27 {
 28 
 29     int i;
 30     for(i = 0;  i< size;  i++)
 31     {
 32         if(mark[i])
 33         {
 34             choose[0] = i;
 35             i++;
 36             break;
 37         }
 38     }
 39     choose[1] = choose[0];
 40     for(; i < size; i++)
 41     {
 42         if(mark[i])
 43         {
 44             if(huffman[choose[0]].key >= huffman[i].key)
 45             {
 46                 choose[1] = choose[0];
 47                 choose[0] = i;
 48             }
 49             else if(huffman[choose[1]].key > huffman[i].key)
 50             {
 51                 choose[1] = i;
 52             }
 53         }
 54 
 55     }
 56 }
 57 void Choose(int *mark, struct node *huffman, int size, int *choose)
 58 {
 59     int i;
 60     int minkey = 0;
 61     int tkey = 0;
 62     int temp = 0;
 63     for(i = 0;  i< size;  i++)
 64     {
 65         if(mark[i])
 66         {
 67             minkey = i;
 68             i++;
 69             break;
 70         }
 71     }
 72     tkey = minkey;
 73     for(;  i< size;  i++)
 74     {
 75         if(mark[i])
 76         {
 77             if(huffman[i].key < huffman[minkey].key)
 78             {
 79                 tkey = minkey;
 80                 minkey = i;
 81             }
 82             if(tkey == minkey)
 83                 tkey = i;
 84             if(huffman[tkey].key > huffman[i].key && i != minkey)
 85             {
 86                 tkey = i;
 87             }
 88         }
 89     }
 90     choose[0] = minkey;
 91     choose[1] = tkey;
 92 }
 93 pnode HuffmanTree(int *mark, struct node *huffman, int size)
 94 {
 95     int choose[2];
 96     int i;
 97     pnode mynode;
 98     for(i = 0;  i < size-1;  i++)
 99     {
100         Select(mark, huffman, size, choose);
101         mynode = (pnode)malloc(sizeof(struct node));
102         mynode->key = huffman[choose[0]].key+huffman[choose[1]].key;//更新key值
103         mynode->l = (pnode)malloc(sizeof(struct node));
104         mynode->l->key = huffman[choose[0]].key;
105         mynode->l->l = huffman[choose[0]].l;
106         mynode->l->r = huffman[choose[0]].r;
107         mynode->r = &huffman[choose[1]];
108         huffman[choose[0]] = *mynode;
109         mark[choose[1]] = 0;
110         free(mynode);
111     }
112     return &huffman[choose[0]];
113 }
114 int main(void)
115 {
116     int key[8] = {5,29,7,8,14,23,3,11};
117     int i;
118     pnode huffmantree;
119     memset(mark, -1, sizeof(mark));
120     memset(huffman, 0, sizeof(huffman));
121     for(i = 0;  i < 8;  i++)
122     {
123         huffman[i].key = key[i];
124     }
125     huffmantree = HuffmanTree(mark, huffman, 8);
126     PreOrder(huffmantree);
127     return 0;
128 }

View Code

在解决acm竞赛题时，可以直接使用C++ STL里的优先队列实现，因为优先队列具有直接排序的功能，可以模拟节点和合并。

这个代码是之前遇到的大顶堆问题，它并不能建立树形结构，只能用来求树的最小带权路径长度。

 1 #include<cstdio>
 2 #include<cstring>
 3 #include<queue>
 4 #include<vector>
 5 #include<algorithm>
 6 #define ll long long int
 7 using namespace std;
 8 int main()
 9 {
10     int n,i;
11     int x,y;
12     int a;
13     ll ans=0;
14     priority_queue<int,vector<int>,greater<int> >q;
15     scanf("%d",&n);
16     for(i=0;i<n;i++)
17     {
18         scanf("%d",&a);
19         q.push(a);
20     }
21     while(q.size()>1)
22     {
23         x=q.top();
24         q.pop();
25         y=q.top();
26         q.pop();
27         ans+=x+y;
28         q.push(x+y);
29     }
30     printf("%lld\n",ans);
31     return 0;
32 }

View Code