C语言构造哈夫曼树、哈夫曼编码

四个叶子节点{1，3，5，5}，构造Huffman树，并进行Huffman编码

设编码时：左分支为‘0’，右分支为‘1’

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

#define MAXVALUE 10000          /* 节点最大权值 */
#define MAXLEAF 30              /* 哈夫曼树叶子节点最大个数 */
#define MAXNODE MAXLEAF * 2 - 1 /* Huffman树中节点总数 */
typedef struct 
{
    int weight;                 /* 节点权值 */
    int parent;                 /* 无双亲节点时为-1，否则为双亲节点下标 */
    int lchild;                 /* 无左孩子时为-1，否则为左孩子下标 */
    int rchild;                 /* 无右孩子时为-1，否则为右孩子下标 */
}HNode, HuffmanTree[MAXNODE];

typedef struct CodeNode/* 编码表的存储结构 */
{
    int weight;/* 存放要表示的符号 */
    char *code;/* 存放相应符号编码 */
}CodeNode, HuffamanCode[MAXLEAF];


/**
 * @description: 构造Huffman树
 * @param w[]：传递n个叶子节点权值
 *               n：叶子节点个数
 */
void CreateHuffmanTree(HuffmanTree HTree, int w[], int n)
{
    /**
     * min1: 集合中最小权值
     * min1: 集合中次小权值 
     * index1：最小权值节点下标
     * index2：次小权值节点下标
     */
    int i, j, min1, min2, index1, index2;

    for (i = 0; i < 2 * n - 1; i++)/* 树中节点初始化 */
    {
        HTree[i].weight = 0;
        HTree[i].parent = -1;
        HTree[i].lchild = -1;
        HTree[i].rchild = -1;
    }
    
    for (i = 0; i < n; i++)
        HTree[i].weight = w[i];
    printf("Huffman树初态\nindex | weight | parent | lchild | rchild\n");
    for (int i = 0; i < 2 * n - 1; i++)
    {
        printf("%3d%9d%9d%9d%9d\n", 
                i, HTree[i].weight, HTree[i].parent, HTree[i].lchild, HTree[i].rchild);
    }
    /************************************************
     * 设n0(叶子节点)、n1(分支为1)、n2(分支为2)分别为二叉树中度为0、1、2的节点个数，
     * n为总节点个数，则 n = n0 + n1 + n2；
     * 设二叉树分支数为B，则 B = n + 1, B = n1 + 2 * n2；
     * 联立上述三个方程--->n0 = n2 + 1;
     * 
     * Huffman树中只有度为0、2的节点：
     * n = n0 + n1 + n2 = n0 + n2；
     * n0 = n2 + 1；
     * Huffman树中：n = 2 * n0 - 1.
     ************************************************/
    for (i = 0; i < n - 1; i++)/* 构造除n个叶子节点外的其余 n - 1 个双亲节点 */
    {
        min1 = min2 = MAXVALUE;
        index1 = index2 = 0;

        for (j = 0; j < n + i; j++)
        {
            if (HTree[j].weight < min1 && HTree[j].parent == -1)
            {/* 若节点权值比min1小且该节点无双亲节点，则更新最小节点 */
                min2 = min1; index2 = index1; /* 更新次小节点 */
                index1 = j;
                min1 = HTree[j].weight;
            }
            else if (HTree[j].weight < min2 && HTree[j].parent == -1)
            {/* 若 min1 < 节点权值 < min2 且该节点无双亲节点，则更新次小节点 */
                index2 = j;
                min2 = HTree[j].weight;
            }
        }

        HTree[index1].parent = n + i;
        HTree[index2].parent = n + i;
        HTree[n+i].weight = HTree[index1].weight + HTree[index2].weight;
        HTree[n+i].lchild = index1;
        HTree[n+i].rchild = index2;
    }
}

/**
 * @description: 从叶子节点-->根节点逆向搜索，若当前节点是其双亲左孩子，置‘0’，否则置‘1’
 * @param：HTree：构造好的Huffman树
 *         HCode：Huffman树叶子节点编码
 *         n：叶子节点个数 
 */
void HuffmanCoding(HuffmanTree HTree, HuffamanCode HCode, int n)
{
    char *cd;
    int i, child, parent, start;

    /* n个叶子节点的Huffman树，叶子节点最长路径为 n-1，加上'\0'，共n个空间 */
    cd = (char *)malloc(n * sizeof(char));
    cd[n-1] = '\0';                 

    for (i = 0; i < n; i++)         /* 求n个叶子节点的Huffman编码 */
    {
        start = n - 1;
        child = i;                  /* child：当前节点下标 */
        parent = HTree[i].parent;   /* parent：当前节点双亲节点下标 */

        while (parent != -1)        /* 若未搜寻至根节点，则一直循环 */
        {
            start--;
            if (HTree[parent].lchild == child) 
                cd[start] = '0';    /* 左孩子，置‘0’ */
            else 
                cd[start] = '1';    /* 右孩子，置‘1’ */
           
            child = parent;         /* 旧双亲节点作为新孩子节点 */
            parent = HTree[parent].parent;/* 旧双亲节点的双亲节点作为新双亲节点 */
        }
        
        HCode[i].code = (char *)malloc((n - start) * sizeof(char));
        HCode[i].weight = HTree[i].weight;
        strcpy(HCode[i].code, &cd[start]);
    }
    free(cd);
}

int main(void)
{
    int w[] = {1, 3, 5, 5}, n = 4;
    HuffmanTree ht;
    HuffamanCode hc;

    CreateHuffmanTree(ht, w, n);
    printf("Huffman树终态\nindex | weight | parent | lchild | rchild\n");
    for (int i = 0; i < 2 * n - 1; i++)
    {
        printf("%3d%9d%9d%9d%9d\n", 
                i, ht[i].weight, ht[i].parent, ht[i].lchild, ht[i].rchild);
    }
    
    HuffmanCoding(ht, hc, n);
    printf("Huffman编码\n节点值  编码\n");
    for (int i = 0; i < n; i++)
    {
        printf("%4d\t%s\n", hc[i].weight, hc[i].code);
    } 
    
    return 0;
}