算法与数据结构 上机----实训操作2 Huffman

利用动态分配数组存储Huffman树,设计一组输入数据（假定为一组整数），能够对其进行如下操作：
创建一个新的顺序表，实现动态空间分配的初始化;
对输入的数据构造成一棵Huffman 树；
根据生成的Huffman 树进行Huffman 编码;
实现对输入数据的Huffman 编码输出;
编写主程序，实现对以上操作的调用。

执行代码：

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

//哈夫曼树与编码的存储表示 
typedef struct {
    int weight;//定义 结点权重
    int parent, left, right;//定义 父结点、左孩子、右孩子在数组中的位置下标
}HTNode, *HuffmanTree;
//动态二维数组，存储哈夫曼编码;动态分配数组存储哈夫曼树 
typedef char ** HuffmanCode; //HT数组中存放的哈夫曼树，end表示HT数组中存放结点的最终位置，
    int i;
	 
void Select(HuffmanTree HT, int end, int *s1, int *s2)
//s1 存放 s2个字符的权值，均>0。
{
    int min1, min2;
    //遍历数组初始下标为 1；记录两个最小的权值 
    int i = 1;
    int j; 
    while(HT[i].parent != 0 && i <= end)//结点双亲值不为0 继续循环找到等于0的结点为止
	{
        i++;
    }
    min1 = HT[i].weight; 
    *s1 = i; 
    i++; 
    while(HT[i].parent != 0 && i <= end)
	{ 
        i++;
    }
  
   //下面对找到的两个结点权，比较大小，min2为储存较大的，min1为储存最小的
    if(HT[i].weight < min1)  
	{
        min2 = min1;
        *s2 = *s1;  //s1和s2传递的是HT数组中权重值最小的两个结点在数组中的位置
        min1 = HT[i].weight;
        *s1 = i;
    }else //否则直接给min2 
	{
        min2 = HT[i].weight;
        *s2 = i;
    }
    //用最先找到的两个没有双亲的结点后续的所有未构建成树的结点做比较
    for(j=i+1; j <= end; j++)
    {
        //如果有父结点，直接跳过，进行下一个
        if(HT[j].parent != 0) 
		{
            continue;
        }
        if(HT[j].weight < min1)  
		{
            min2 = min1;
            min1 = HT[j].weight;
            *s2 = *s1;
            *s1 = j;
        }
        else if(HT[j].weight >= min1 && HT[j].weight < min2){
            min2 = HT[j].weight;
            *s2 = j;
        }
    }
}


//HT为地址传递的存储哈夫曼树的数组，w为存储结点权重值的数组，n为结点个数
void CreateHuffmanTree(HuffmanTree *HT, int *w, int n)
{
    if(n<=1) return; // 如果只有一个编码就相当于0
    int m = 2*n-1;
	 // 哈夫曼树总节点数，2n-1就是叶子结点
    *HT = (HuffmanTree) malloc((m+1) * sizeof(HTNode)); 
    HuffmanTree p = *HT;
    // 初始化哈夫曼树中的所有结点
    for(i = 1; i <= n; i++)  //循环输入权值 
    {
        (p+i)->weight = *(w+i-1);
        (p+i)->parent = 0;
        (p+i)->left = 0;
        (p+i)->right = 0;
    }
    //从树组的下标 n+1 开始初始化哈夫曼树中除叶子结点外的结点
    for(i = n+1; i <= m; i++)
    {
        (p+i)->weight = 0;
        (p+i)->parent = 0;
        (p+i)->left = 0;
        (p+i)->right = 0;
    }
    //构建哈夫曼树
    for(i = n+1; i <= m; i++)
    {
        int s1, s2; //s1和s2是最小值和次最小值在数组里的下标 
        Select(*HT, i-1, &s1, &s2);
        (*HT)[s1].parent = (*HT)[s2].parent = i; 
        (*HT)[i].left = s1;
        (*HT)[i].right = s2;
        (*HT)[i].weight = (*HT)[s1].weight + (*HT)[s2].weight; //新结点等于两孩子的权值之和 
        //从叶子到跟逆向求每个字符的哈夫曼编码 
    }
}


 //HT为哈夫曼树，HC为存储结点哈夫曼编码的二维动态数组，n为结点的个数
void HuffmanCoding(HuffmanTree HT, HuffmanCode *HC,int n)//构造哈夫曼树HT，求出s2个字符的哈夫曼编码 
{
    *HC = (HuffmanCode) malloc((n+1) * sizeof(char *)); 
    char *cd = (char *)malloc(n*sizeof(char));  
    cd[n-1] = '\0';//添加字符串结束符，编码结束符。 
   
   //逐个字符求哈夫曼编码 
    for(i=1; i<=n; i++){
        //从叶子结点出发，得到的哈夫曼编码是逆序的，需要在字符串数组中逆序存放
        int start = n-1;
        int c = i;
        int j = HT[i].parent;
        // 一直寻找到根结点；当前叶子结点的双亲结点位置 
        while(j != 0){
            // 如果该结点是父结点的左孩子则对应路径编码为0，否则为右孩子编码为1
            if(HT[j].left == c)
                cd[--start] = '0';
            else
                cd[--start] = '1';
            //以父结点为孩子结点，继续朝树根的方向遍历
            c = j;
            j = HT[j].parent;
        }
        //跳出循环后，cd数组中从下标 start 开始，存放的就是该结点的哈夫曼编码
        (*HC)[i] = (char *)malloc((n-start)*sizeof(char));//为第i个字符编码分配空间 
        strcpy((*HC)[i], &cd[start]);//给cd复制编码串到哈夫曼编码HC 
    }
    //使用malloc申请的cd动态数组需要手动释放
    free(cd); //释放工作空间 
}

//打印哈夫曼编码的函数
void PrintHuffmanCode(HuffmanCode htable,int *w,int n)
{
    printf("Huffman code : \n");
    for(i = 1; i <= n; i++)
        printf("%d code = %s\n",w[i-1], htable[i]);
}
int main(void)
{
    int w[5] = {2, 8, 7, 6, 5};
    int n = 5;
    HuffmanTree htree;
    HuffmanCode htable;
    CreateHuffmanTree(&htree, w, n);
    HuffmanCoding(htree, &htable, n);
    PrintHuffmanCode(htable,w, n);
    return 0;
}

执行结果：

• C程序