算法步骤：
1.分配存储n个字符编码的编码表空间HC，长度为n+1(为何长度为n+1？各字符的哈夫曼编码存储在有HuffmanCode定义的动态分配的数组HC中，为了实现方便，数组的0号单元不使用，从1号单元开始使用)；分配临时存储每个字符编码的动态数组空间cd，cd[n-1] 置为‘\0’（存放字符串结束标志）。
2.逐个求解n个字符的编码，循环n次，执行下列操作
a.设置变量start用于记录编码在cd中存放的位置，start初始时指向最后，即编码结束符位置n-1（为何指向最后？因为求解编码时是从哈夫曼的叶子出发，向上回溯至根节点，所以对于每个字符，得到的编码顺序是从右向左的，所以编码向数组cd存放的顺序也是从后向前的，即每个字符的第一个编码存放在cd[n-1]）
b.设置变量c用于记录叶子结点向上回溯至根节点所经过的结点下标，c初始时为当前待编码字符的下标i，f用于记录i的双亲节点的下标；
c.从叶子结点向上回溯至根节点，求得字符i的编码，当f没有到达根节点时，循环执行以下操作：
（1）回溯一次start向前指一个位置，即--start；
（2）若结点c是f的左孩子，则生成代码0，否则生成代码1，生成的代码0或1保存在cd[start]中；
（3）继续向上回溯，改变c和f的值
d.根据数组cd的字符串长度为第i个字符编码分配空间HC[i],然后将数组cd中的编码赋值到HC[i]中
3.释放临时空间cd。
typedef char**HuffmanCode;
void CreatHuffmanCode(HuffmanTree HT,HuffmanCode &HC,int n)
{
//从叶子到根逆向求每个字符的哈夫曼编码，存储在编码表HC中
HC=new char*[n+1];//分配存储n个字符编码的编码表空间
cd=new char[n];//分配临时存放每个字符编码的动态数组空间
cd[n-1]='\0';//编码结束符
for(i=1;i<=n;++i)//逐个字符求哈夫曼编码
{
start=n-1;//start开始时指向最后，即编码结束符位置
c=i;f-HT[i].parent;//f指向结点c的双亲节点
while(f!=0)
{
--start;//回溯一次start向前指一个位置
if(HT[f].lchild==c)
cd[start]='0';
else cd[start]='1';
c=f;
f=HT[f].parent;//继续向上回溯
}//求出第i个字符的编码
HC[i]=new char[n-start];//为第i个字符编码分配空间
strcpy(HC[i],&cd[start]);//将求得的编码从临时空间cd复制到HC的当前行中
}
delete cd;//释放临时空间
}例题：已知某系统在通信联络中只可能出现8种字符，其概率分别为0.05,0.29,0.07,0.08,0.14,0.23,0.03,0.11，设计哈夫曼编码
具体步骤和代码
步骤1：构建哈夫曼树
-
输入字符及其概率：
vector<double> weights = {0.05, 0.29, 0.07, 0.08, 0.14, 0.23, 0.03, 0.11}; int n = weights.size(); -
初始化哈夫曼树节点：
HuffmanTree HT; HT.resize(2 * n); -
构建哈夫曼树：
void CreateHuffmanTree(HuffmanTree &HT, vector<double> &weights) { int n = weights.size(); int m = 2 * n - 1; for (int i = 1; i <= n; ++i) { HT[i].weight = weights[i - 1]; } for (int i = n + 1; i <= m; ++i) { // 选择权重最小的两个节点 int s1 = -1, s2 = -1; for (int j = 1; j < i; ++j) { if (HT[j].parent == 0) { if (s1 == -1 || HT[j].weight < HT[s1].weight) { s2 = s1; s1 = j; } else if (s2 == -1 || HT[j].weight < HT[s2].weight) { s2 = j; } } } // 合并最小的两个节点 HT[s1].parent = i; HT[s2].parent = i; HT[i].lchild = s1; HT[i].rchild = s2; HT[i].weight = HT[s1].weight + HT[s2].weight; } }
步骤2：生成哈夫曼编码
-
分配存储编码表的空间：
HuffmanCode HC = new char*[n + 1]; -
生成编码：
void CreateHuffmanCode(HuffmanTree &HT, HuffmanCode &HC, int n) { char* cd = new char[n]; cd[n - 1] = '\0'; for (int i = 1; i <= n; ++i) { int start = n - 1; int c = i; int f = HT[c].parent; while (f != 0) { if (HT[f].lchild == c) { cd[--start] = '0'; } else { cd[--start] = '1'; } c = f; f = HT[f].parent; } HC[i] = new char[n - start]; strcpy(HC[i], &cd[start]); } delete[] cd; } -
输出编码：
for (int i = 1; i <= n; ++i) { cout << "Character " << i << " Huffman Code: " << HC[i] << endl; } -
释放内存：
for (int i = 1; i <= n; ++i) { delete[] HC[i]; } delete[] HC;
#include <iostream> // 引入标准输入输出流库
#include <cstring> // 引入字符串操作库
#include <vector> // 引入动态数组库
using namespace std; // 使用标准命名空间
// 定义哈夫曼树节点结构体
struct HTNode {
double weight; // 节点权重，即字符的概率
int parent, lchild, rchild; // 父节点、左孩子、右孩子的索引
};
typedef vector<HTNode> HuffmanTree; // 定义哈夫曼树类型，使用动态数组存储节点
typedef char** HuffmanCode; // 定义哈夫曼编码类型，指向字符数组的指针
// 创建哈夫曼树的函数，输入字符权重的向量
void CreateHuffmanTree(HuffmanTree &HT, vector<double> &weights) {
int n = weights.size(); // 获取字符个数
if (n <= 1) return; // 如果字符个数小于等于1，不需要构建哈夫曼树
int m = 2 * n - 1; // 哈夫曼树节点总数，满二叉树的节点数
HT.resize(m + 1); // 调整哈夫曼树的大小以容纳所有节点
// 初始化前n个节点（叶子节点）
for (int i = 1; i <= n; ++i) {
HT[i].weight = weights[i - 1]; // 设置节点权重
HT[i].parent = 0; // 初始化父节点索引为0
HT[i].lchild = 0; // 初始化左孩子索引为0
HT[i].rchild = 0; // 初始化右孩子索引为0
}
// 初始化剩余的m-n个节点（非叶子节点）
for (int i = n + 1; i <= m; ++i) {
HT[i].weight = 0; // 初始权重为0
HT[i].parent = 0; // 初始化父节点索引为0
HT[i].lchild = 0; // 初始化左孩子索引为0
HT[i].rchild = 0; // 初始化右孩子索引为0
}
// 构建哈夫曼树
for (int i = n + 1; i <= m; ++i) {
int s1 = -1, s2 = -1; // 初始化最小两个权重节点的索引
// 选择权重最小的两个节点
for (int j = 1; j <= i - 1; ++j) {
if (HT[j].parent == 0) { // 该节点没有父节点
if (s1 == -1) {
s1 = j; // 设置第一个最小权重节点
} else if (s2 == -1) {
s2 = j; // 设置第二个最小权重节点
} else if (HT[j].weight < HT[s1].weight) {
s2 = s1; // 调整s1和s2
s1 = j; // s1指向新的最小权重节点
} else if (HT[j].weight < HT[s2].weight) {
s2 = j; // s2指向第二小的权重节点
}
}
}
// 设置新节点i的左右孩子
HT[i].lchild = s1;
HT[i].rchild = s2;
HT[i].weight = HT[s1].weight + HT[s2].weight; // 新节点的权重为两个孩子节点权重之和
HT[s1].parent = i; // 更新孩子节点的父节点索引
HT[s2].parent = i; // 更新孩子节点的父节点索引
}
}
// 创建哈夫曼编码的函数，输入哈夫曼树和字符数量，输出哈夫曼编码表
void CreateHuffmanCode(HuffmanTree &HT, HuffmanCode &HC, int n) {
HC = new char*[n + 1]; // 分配存储n个字符编码的编码表空间
char* cd = new char[n]; // 分配临时存放每个字符编码的动态数组空间
cd[n - 1] = '\0'; // 编码结束符
// 逐个字符求哈夫曼编码
for (int i = 1; i <= n; ++i) {
int start = n - 1; // start开始时指向最后，即编码结束符位置
int c = i; // 当前节点索引
int f = HT[i].parent; // f指向结点c的双亲节点
while (f != 0) { // 逆向回溯直到根节点
if (HT[f].lchild == c) {
cd[--start] = '0'; // 左孩子编码为'0'
} else {
cd[--start] = '1'; // 右孩子编码为'1'
}
c = f; // 回溯到父节点
f = HT[f].parent; // 继续向上回溯
}
HC[i] = new char[n - start]; // 为第i个字符编码分配空间
strcpy(HC[i], &cd[start]); // 将求得的编码从临时空间cd复制到HC的当前行中
}
delete[] cd; // 释放临时空间
}
int main() {
vector<double> weights = {0.05, 0.29, 0.07, 0.08, 0.14, 0.23, 0.03, 0.11}; // 定义字符概率
int n = weights.size(); // 获取字符数量
HuffmanTree HT; // 定义哈夫曼树
CreateHuffmanTree(HT, weights); // 创建哈夫曼树
HuffmanCode HC; // 定义哈夫曼编码表
CreateHuffmanCode(HT, HC, n); // 创建哈夫曼编码
// 输出每个字符的哈夫曼编码
for (int i = 1; i <= n; ++i) {
cout << "Character " << i << " Huffman Code: " << HC[i] << endl;
}
// 释放哈夫曼编码表的空间
for (int i = 1; i <= n; ++i) {
delete[] HC[i];
}
delete[] HC;
return 0; // 程序结束
}
代码详细注释
-
#include <iostream>: 用于标准输入输出操作，如std::cout和std::endl。 -
#include <cstring>: 用于字符串操作，如std::strcpy。 -
#include <vector>: 用于动态数组操作，便于存储哈夫曼树节点。 -
struct HTNode: 定义哈夫曼树节点的结构，包括权重、父节点、左孩子和右孩子的索引。 -
typedef vector<HTNode> HuffmanTree: 定义哈夫曼树类型，使用std::vector存储节点。 -
typedef char** HuffmanCode: 定义哈夫曼编码类型，指向字符数组的指针。 -
void CreateHuffmanTree(HuffmanTree &HT, vector<double> &weights): 创建哈夫曼树的函数。int n = weights.size(): 获取字符个数。if (n <= 1) return: 如果字符个数小于等于1，不需要构建哈夫曼树。int m = 2 * n - 1: 计算哈夫曼树节点总数。HT.resize(m + 1): 调整哈夫曼树的大小以容纳所有节点。for (int i = 1; i <= n; ++i): 初始化前n个节点（叶子节点）。for (int i = n + 1; i <= m; ++i): 初始化剩余的m-n个节点（非叶子节点）。for (int i = n + 1; i <= m; ++i): 构建哈夫曼树，通过选择权重最小的两个节点合并。
-
void CreateHuffmanCode(HuffmanTree &HT, HuffmanCode &HC, int n): 创建哈夫曼编码的函数。HC = new char*[n + 1]: 分配存储n个字符编码的编码表空间。char* cd = new char[n]:
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
