数据结构之哈夫曼树
这部分内容为偏向于底层方面的哈夫曼树，样例代码为文件的读写，由于老师给出的代码并未给出运行截图，所以我并不知道我写的代码是否运行正确。
代码如下
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <fstream>
#include <string.h>
using namespace std;
#define MaxSize 1024 // 读入文件的上限
#define OK 1
#define ERROR 0
typedef int Status;
typedef struct wordcnt { // 统计字符和对应的次数
char ch;
int cnt = 0;
}Count;
typedef struct NumCount { // 统计次数的外部封装
Count count[MaxSize];
int length = 0;
}NumCount;
typedef struct HTree { // 哈夫曼树结构
char data;
int weight;
int parent, lchild, rchild;
}HTNode, *HuffmanTree;
typedef struct HCode { // 编码结构
char data;
char* str;
}*HuffmanCode;
Status ReadData(char *source); // 读入文件
Status WordCount(char *data, NumCount *paraCnt); // 统计次数
Status Show(NumCount *paraCnt); // 展示次数
Status CreateHuffmanTree(HuffmanTree &HT, int length, NumCount cntarray); // 创建哈夫曼树
Status select(HuffmanTree HT, int top, int *s1, int *s2); // 选择权重最小的两个节点
Status CreateHuffmanCode(HuffmanTree HT, HuffmanCode &HC, int length); // 创建哈夫曼编码
Status Encode(char *data, HuffmanCode HC, int length); // 将读入的文件编码，写到txt文件
Status Decode(HuffmanTree HT, int length); //读入编码文件，解码
int main(int argc, char** argv) {
char data[MaxSize];
NumCount Cntarray;
ReadData(data); // 读入数据
WordCount(data, &Cntarray); // 统计次数
HuffmanTree tree;
CreateHuffmanTree(tree, Cntarray.length, Cntarray); // 建树
HuffmanCode code;
CreateHuffmanCode(tree, code, Cntarray.length); // 创建编码
Encode(data, code, Cntarray.length); // 生成编码文件
Decode(tree, Cntarray.length); // 解码
cout << "Please view the generated TXT file to check the result" << endl;
return 0;
}
Status ReadData(char *source)
{
//打开文件读入数据
ifstream infile;
infile.open("in.txt");
cout << "Reading..." << endl;
cout << "the input file is:" << endl;
infile.getline(source, MaxSize);
cout << source << endl;
infile.close();
cout << endl;
return OK;
}
Status WordCount(char *data, NumCount *paraCnt)
{
int flag;// 标识是否已经记录
int len = strlen(data);
for (int i = 0; i < len; ++i)
{
flag = 0;
for (int j = 0; j < paraCnt->length; ++j)
{
if (paraCnt->count[j].ch == data[i]) // 若已有记录，直接++
{
++paraCnt->count[j].cnt;
flag = 1;
break;
}
}
if (!flag) // 没有记录，则新增
{
paraCnt->count[paraCnt->length].ch = data[i];
++paraCnt->count[paraCnt->length].cnt;
++paraCnt->length;
}
}
return OK;
}
Status Show(NumCount *paraCnt)
{
cout << "the length is " << paraCnt->length << endl;
for (int i = 0; i < paraCnt->length; ++i)
{
cout << "The character " << paraCnt->count[i].ch << " appears " << paraCnt->count[i].cnt << endl;
}
cout << endl;
return OK;
}
Status CreateHuffmanTree(HuffmanTree &HT, int length, NumCount cntarray)
{
if (length <= 1) return ERROR;
int s1, s2;
int m = length * 2 - 1; // 没有度为1的节点，则总结点是2*叶子节点数-1个
HT = new HTNode[m + 1];
for (int i = 1; i <= m; ++i) // 初始化
{
HT[i].parent = 0;
HT[i].lchild = 0;
HT[i].rchild = 0;
}
for (int i = 1; i <= length; ++i)
{
HT[i].data = cntarray.count[i - 1].ch;
HT[i].weight = cntarray.count[i - 1].cnt;
}
for (int i = length + 1; i <= m; ++i)
{
select(HT, i - 1, &s1, &s2); // 从前面的范围里选择权重最小的两个节点
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; // 得到一个新节点
}
return OK;
}
Status select(HuffmanTree HT, int top, int *s1, int *s2)
{
int min = INT_MAX;
for (int i = 1; i <= top; ++i) // 选择没有双亲的节点中，权重最小的节点
{
if (HT[i].weight < min && HT[i].parent == 0)
{
min = HT[i].weight;
*s1 = i;
}
}
min = INT_MAX;
for (int i = 1; i <= top; ++i) // 选择没有双亲的节点中，权重次小的节点
{
if (HT[i].weight < min && i != *s1 && HT[i].parent == 0)
{
min = HT[i].weight;
*s2 = i;
}
}
return OK;
}
Status CreateHuffmanCode(HuffmanTree HT, HuffmanCode &HC, int length)
{
HC = new HCode[length + 1];
char *cd = new char[length]; // 存储编码的临时空间
cd[length - 1] = '\0'; // 方便之后调用strcpy函数
int c, f, start;
for (int i = 1; i <= length; ++i)
{
start = length - 1; // start表示编码在临时空间内的起始下标，由于是从叶子节点回溯，所以是从最后开始
c = i;
f = HT[c].parent;
while (f != 0)
{
--start; // 由于是回溯，所以从临时空间的最后往回计
if (HT[f].lchild == c)
cd[start] = '0';
else
cd[start] = '1';
c = f;
f = HT[c].parent;
}
HC[i].str = new char[length - start]; // 最后，实际使用的编码空间大小是length-start
HC[i].data = HT[i].data;
strcpy(HC[i].str, &cd[start]); // 从实际起始地址开始，拷贝到编码结构中
}
delete cd;
return 1;
}
Status Encode(char *data, HuffmanCode HC, int length)
{
ofstream outfile;
outfile.open("code.txt");
for (int i = 0; i < strlen(data); ++i) // 依次读入数据，查找对应的编码，写入编码文件
{
for (int j = 1; j <= length; ++j)
{
if (data[i] == HC[j].data)
{
outfile << HC[j].str;
}
}
}
outfile.close();
cout << "the code txt has been written" << endl;
cout << endl;
return OK;
}
Status Decode(HuffmanTree HT, int length)
{
char codetxt[100001];
ifstream infile;
infile.open("code.txt");
infile.getline(codetxt, MaxSize*length);
infile.close();
ofstream outfile;
outfile.open("out.txt");
int root = 2 * length - 1; // 从根节点开始遍历
for (int i = 0; i < strlen(codetxt); ++i)
{
if (codetxt[i] == '0') root = HT[root].lchild; //为0表示向左遍历
else if (codetxt[i] == '1') root = HT[root].rchild; //为1表示向右遍历
if (HT[root].lchild == 0 && HT[root].rchild == 0) // 如果已经是叶子节点，输出到输出文件中，然后重新回到根节点
{
outfile << HT[root].data;
root = 2 * length - 1;
}
}
outfile.close();
cout << "the output txt has been written" << endl;
cout << endl;
return OK;
}
运行截图
思路讲解
哈夫曼树是一种特殊的二叉树，它的每个叶子节点都有一个权值，而且权值越大的叶子节点越靠近根节点。哈夫曼树的构造方法是：
- 首先将所有的叶子节点按照权值从小到大排序，然后每次取出最小的两个节点，合并成一个新的节点，新节点的权值为两个子节点的权值之和，然后将新节点插入到原来的序列中，重复这个过程直到只剩下一个节点，这个节点就是哈夫曼树的根节点。
- 其次，从根节点开始遍历这棵树，并且给每条边赋予一个bit值：左边为0，右边为1。最后我们可以得到每个叶子节点对应的编码：从根节点到叶子节点经过的所有边上的bit值组成。
举个例子，假设我们有四个叶子节点，它们的权值分别为2，3，4，6。我们可以按照如下步骤构造哈夫曼树：
-
将四个叶子节点按照权值排序：2，3，4，6。
-
取出最小的两个节点2和3，合并成一个新的节点5，5的权值为2+3=5。将5插入到原来的序列中：4，5，6。
-
取出最小的两个节点4和5，合并成一个新的节点9，9的权值为4+5=9。将9插入到原来的序列中：6，9。
-
取出最小的两个节点6和9，合并成一个新的节点15，15的权值为6+9=15。将15插入到原来的序列中：15。
-
此时只剩下一个节点15，它就是哈夫曼树的根节点。
-
从根节点开始遍历这棵树，并且给每条边赋予一个bit值：左边为0，右边为1。我们可以得到每个叶子节点对应的编码：
- 2 -> 00
- 3 -> 01
- 4 -> 10
- 6 -> 11
学习思考
哈夫曼树是一种特殊的二叉树，它的每个叶子节点都有一个权值，而且权值越大的叶子节点越靠近根节点。哈夫曼树的构造方法是：首先将所有的叶子节点按照权值从小到大排序，然后每次取出最小的两个节点，合并成一个新的节点，新节点的权值为两个子节点的权值之和，然后将新节点插入到原来的序列中，重复这个过程直到只剩下一个节点，这个节点就是哈夫曼树的根节点。
哈夫曼树有什么用呢？它可以用来进行数据的压缩和编码。我们知道，数据在计算机中是以二进制位（bit）来存储和传输的，每个bit只能表示0或1两种状态。如果我们想要表示更多的信息，就需要用更多的bit。比如，如果我们想要表示26个英文字母，就需要用5个bit（因为2^5=32>26），那么一个英文单词就需要用5乘以单词长度个bit来表示。这样会占用很多的存储空间和传输带宽。
但是，我们可以发现，英文中并不是所有的字母都出现得一样频繁，有些字母比如e、a、t等出现得很多，而有些字母比如q、z、x等出现得很少。如果我们能够给出现得多的字母分配较短的编码，而给出现得少的字母分配较长的编码，那么我们就可以节省很多的bit。比如，如果我们给e分配编码0，给a分配编码10，给t分配编码110等等，那么一个英文单词就可以用平均3.5个bit左右来表示（这个数字是根据英文中各个字母出现频率计算得到的）。这样就可以大大压缩数据。
但是，这样的编码方式有一个问题，就是如何区分不同的字母。比如，如果我们看到一个编码序列01011010，我们不知道它是表示eaat还是etaa还是其他什么组合。为了解决这个问题，我们需要保证编码具有前缀性，也就是说任何一个字母的编码都不是另一个字母的编码的前缀。这样我们就可以从左到右依次识别每个字母。比如，如果我们看到一个编码序列01011010，我们可以确定它是表示eat。
那么如何构造具有前缀性的编码呢？这就是哈夫曼树可以帮助我们做到的事情。我们可以把每个字母看作一个叶子节点，并且把它们出现的频率作为权值。然后按照哈夫曼树的构造方法生成一棵哈夫曼树。接着我们可以从根节点开始遍历这棵树，并且给每条边赋予一个bit值：左边为0，右边为1。最后我们可以得到每个叶子节点对应的编码：从根节点到叶子节点经过的所有边上的bit值组成。由于哈夫曼树具有最小外部路径长度（也就是所有叶子节点到根节点路径长度之和最小）的性质，所以这样得到的编码也具有最小平均长度（也就是所有字母对应编码长度之和最小）的性质。而且由于哈夫曼树是一棵二叉树，所以这样得到的编码也具有前缀性。
构造具有前缀性的编码呢？这就是哈夫曼树可以帮助我们做到的事情。我们可以把每个字母看作一个叶子节点，并且把它们出现的频率作为权值。然后按照哈夫曼树的构造方法生成一棵哈夫曼树。接着我们可以从根节点开始遍历这棵树，并且给每条边赋予一个bit值：左边为0，右边为1。最后我们可以得到每个叶子节点对应的编码：从根节点到叶子节点经过的所有边上的bit值组成。由于哈夫曼树具有最小外部路径长度（也就是所有叶子节点到根节点路径长度之和最小）的性质，所以这样得到的编码也具有最小平均长度（也就是所有字母对应编码长度之和最小）的性质。而且由于哈夫曼树是一棵二叉树，所以这样得到的编码也具有前缀性。
通过学习哈夫曼树，我对数据结构和算法有了更深刻的理解和兴趣。我认识到数据结构和算法不仅仅是抽象和理论化的知识，而且也有很多实际和应用化的价值。我也体会到了数据结构和算法之间相互联系和影响的关系。我希望能够继续学习更多关于数据结构和算法方面的知识，并且将它们运用到实际问题中去。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
