C语言描述哈夫曼树算法,先序遍历哈夫曼树进行哈夫曼编码（c语言描述）

半年前写的代码，为了契合教材上的规范再加上当时不是很熟练，很多地方写的很繁杂，目前发现bug是，叶节点，即要编码的字符只有一个的时候PrintHuffmanCode函数会出错，可以自行加上编码字符个数判断。

学校数据结构实验(c语言描述)布置了写求哈夫曼编码的作业，书上采用的是从叶子到根逆向求编码的方式(清华版数据结构c语言描述)，我这里给出先序遍历，即“根左右”进行哈夫曼编码的代码

#include

#include

#include

typedef char** HuffmanCode;//存储哈夫曼编码的数据结构

typedef enum { OVERFLOW = -2, OK = 1, ERROR = 0 }Status;//判断异常的状态类型

typedef struct {

int weight;

int parent, lchild, rchild;

}HTNode, * HTList;//哈夫曼树的节点数据结构，包含节点的权重，双亲、左右孩子的下标(采用顺序结构存储哈弗曼树)

typedef struct {

HTList root;

HuffmanCode code;

int nums;

}HuffmanTree;//哈夫曼树的数据结构，root为哈弗曼树节点的一个顺序表，code为存储各叶子节点的二维数组，nums为叶子节点的数目

//从root顺序表中0~upperbound范围内选择两个权重最小，且未链接上双亲的节点，将其下标存储在index数组中

void Select(HTList root, int upper_bound, int* index) {

int value[2];

index[0] = -1, index[1] = -1;

value[0] = 100, value[1] = 100;

for (int i = 0; i < upper_bound; i++) {

if (root[i].parent == -1) {//parent=-1代表无双亲(还没有链接上双亲

if (root[i].weight < value[0] && root[i].weight >= value[1]) {

value[0] = root[i].weight;

index[0] = i;

}

if (root[i].weight < value[1] && root[i].weight >= value[0]) {

value[1] = root[i].weight;

index[1] = i;

}

if (root[i].weight < value[0] && root[i].weight < value[1]) {

(value[0] < value[1] ? value[1] : value[0]) = root[i].weight;

(root[i].weight == value[1] ? index[1] : index[0]) = i;

}

}

}

}

//对一颗完整的哈夫曼树编码，next_pos用以指示下一次递归该去的位置(因为顺序表的递归不比链表方便)；a_code数组用以存储每一次求出的叶子节点的哈弗曼编码;p指针可想象成指示a_code数组元素的光标

void HuffmanEncoding(HuffmanTree& tree, int next_pos, char** p, char a_code[]) {

if (tree.root[next_pos].lchild != -2) {//对于完全二叉树，左子树不为空，右子树也必定不为空

**p = '0';

(*p)++;

HuffmanEncoding(tree, tree.root[next_pos].lchild, p, a_code);//若左子树不为空，将左子树的位置作为下一层递归时根的位置

**p = '1';

(*p)++;

HuffmanEncoding(tree, tree.root[next_pos].rchild, p, a_code);//同上

}

else {

**p = '\0';//为了字符串复制作准备

tree.code[next_pos] = (char*)malloc(tree.nums * sizeof(char));

strcpy(tree.code[next_pos], a_code);

}

(*p)--;

}//先序遍历哈夫曼树求哈夫曼编码

//由叶子节点采用哈弗曼算法构造出完整的哈弗曼树

Status GetHuffmanTree(HuffmanTree& huffman_tree, int* weight) {

if (huffman_tree.nums <= 1)//若叶子节点只有一个或没有那还编什么...

return ERROR;

int nodes = 2 * huffman_tree.nums - 1;//哈弗曼树应有的总节点数，完全二叉树节点计算公式

char* a_code = (char*)malloc(huffman_tree.nums * sizeof(char));//每个叶子节点的哈夫曼编码长度不会超过叶子节点数目

char** p = &a_code;//光标指针p，用以操作a_code数组

huffman_tree.root = (HTList)malloc(nodes * sizeof(HTNode));//首元素为哈弗曼树的根的节点数组

huffman_tree.code = (char**)malloc(huffman_tree.nums * sizeof(char*));

int* index = (int*)malloc(2 * sizeof(int));

for (int i = 0; i < nodes; i++) {

if (i < huffman_tree.nums) {

huffman_tree.root[i].weight = *(weight + i);

huffman_tree.root[i].lchild = -2, huffman_tree.root[i].rchild = -2;//叶子节点左右孩子索引,意义是空

huffman_tree.root[i].parent = -1;//待链接的节点父母索引

}//将叶子节点按在weight数组中的顺序存入root节点数组中

else {

Select(huffman_tree.root, i, index);

huffman_tree.root[index[0]].parent = i, huffman_tree.root[index[1]].parent = i;

huffman_tree.root[i].weight = huffman_tree.root[index[0]].weight + huffman_tree.root[index[1]].weight;

huffman_tree.root[i].lchild = huffman_tree.root[index[0]].weight < huffman_tree.root[index[1]].weight ? index[0] : index[1];//权值较小者作为左孩子

huffman_tree.root[i].rchild = (huffman_tree.root[i].lchild == index[0] ? index[1] : index[0]);

huffman_tree.root[i].parent = -1;

}//以这nums个叶子节点构建哈夫曼树

}

huffman_tree.root[nodes - 1].parent = -2;//根节点父母索引,意义为空

HuffmanEncoding(huffman_tree, nodes - 1, p, a_code);

return OK;

}

void PrintHuffmanCode(HuffmanTree tree) {

for (int i = 0; i < tree.nums; i++) {

printf("weight:%3d code:%s\n", tree.root[i].weight, tree.code[i]);

}

}

int main() {//示例

HuffmanTree tree;

int weight[5] = { 10,20,30,35,5 };

int nums = 5;

tree.nums = nums;

GetHuffmanTree(tree, weight);

PrintHuffmanCode(tree);

return 0;

}

对c语言指针感到迷惑的人可能不能理解p指针的作用。我在上面注释里写"把p指针理解为光标"，这其实不太准确，应该说是"指向光标的光标"。

首先不能直接对a_code数组的首地址进行加加减减的操作，如a_code++,这样会使你的数组首地址发生变化，想象a_code存储以下字符串“001011”,你对a_code++,那么你的字符串就会变成"01011"，这样会使你后面将a_code复制到code数组里的操作错误。

然后来理解指针的含义。可以把指针也当做一个变量，只是这种变量存储的值较为特殊，他存储的是别的变量的地址。所谓地址，就是变量在内存区域的索引之类的东西，实际上也是一个数字(可以用printf打印变量a的地址&a或数组b起始地址b看看)。

理解了指针之后再来看为什么不定义char *p=a_code，而是定义 char **p=&a_code。采用前者的p指针，他存储的内容是数组a_code的首地址，当p指针加减时，也就是a_code首地址基础上进行加减(但不改变a_code数组地址，也就不会发生前面提到的字符串变化的情况)。

c语言存在局部变量与全局变量的东西。在HuffmanEncoding中的指针p，其实与GetHuffmanTree里面定义的指针p不是同一个东西，只是名字相同，存储地址是不同的。在GetHuffmanTree函数中调用HuffmanEncoding函数，是另外在栈中定义了一个同样类型的变量，并把指针p的内容传给了这个新定义的变量。

回到上面怎样定义p指针的话题，若采用前者定义，由于当遍历到叶子节点时，不再递归下去，也就没有把p指针自减后的值后传给回溯的函数体里，就起不到遇到叶子节点复制完光标退一格的效果。

若采用后者定义，相当于你定义了一个指向上一段提到的p指针的指针，这样你就不用担心你的p指针改变后实际却没有改变的情况了。

讲的有点晦涩，如果理解不了可以自己动手改成前者定义方式看看结果如何。