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

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

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

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

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指针改变后实际却没有改变的情况了。
讲的有点晦涩，如果理解不了可以自己动手改成前者定义方式看看结果如何。