用c语言1.设计哈夫曼树。具体构造方法如下：以字符集{A,B,C,D,E,F,G,H}作为叶子结点，以各个字符出现的字符次数{5，29，7，8，14，23，3，11}作为各个叶子结点的权值构造哈夫曼树。 2.设计哈夫曼编码。按照构造出来的哈夫曼树，规定哈夫曼树的左分支为0，右分支为1，则从根结点到每个叶子结点所经过的分支对应的0和1组成的序列便是该结点对应字符的哈夫曼编码。

以下是C语言实现哈夫曼树和哈夫曼编码的代码：

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

// 定义哈夫曼树节点结构体
typedef struct HuffmanNode {
    char ch;  // 节点对应的字符
    int weight;  // 节点的权值
    int parent;  // 节点的父节点下标
    int leftChild;  // 节点的左孩子下标
    int rightChild;  // 节点的右孩子下标
} HuffmanNode;

// 构造哈夫曼树
void createHuffmanTree(HuffmanNode *nodes, int n)
{
    int i, j, k;
    int min1, min2;
    // 初始化所有节点
    for (i = 0; i < 2 * n - 1; i++) {
        nodes[i].parent = -1;
        nodes[i].leftChild = -1;
        nodes[i].rightChild = -1;
    }
    // 初始化叶子节点
    for (i = 0; i < n; i++) {
        nodes[i].ch = 'A' + i;
        nodes[i].weight = 5 + 6 * i;
    }
    // 构造哈夫曼树
    for (i = n; i < 2 * n - 1; i++) {
        min1 = min2 = 99999;
        k = 0;
        for (j = 0; j < i; j++) {
            if (nodes[j].parent == -1 && nodes[j].weight < min1) {
                min2 = min1;
                min1 = nodes[j].weight;
                k = j;
            } else if (nodes[j].parent == -1 && nodes[j].weight < min2) {
                min2 = nodes[j].weight;
            }
        }
        nodes[k].parent = i;
        nodes[i].leftChild = k;
        nodes[i].weight = min1 + min2;
        for (j = 0; j < i; j++) {
            if (nodes[j].parent == -1 && nodes[j].weight == min2) {
                nodes[j].parent = i;
                nodes[i].rightChild = j;
            }
        }
    }
}

// 构造哈夫曼编码
void createHuffmanCode(HuffmanNode *nodes, int n, char **codes)
{
    int i, j, k;
    char *code = (char *) malloc(n * sizeof(char));
    code[n - 1] = '\0';
    for (i = 0; i < n; i++) {
        k = i;
        j = n - 2;
        while (nodes[k].parent != -1) {
            if (nodes[nodes[k].parent].leftChild == k) {
                code[j--] = '0';
            } else {
                code[j--] = '1';
            }
            k = nodes[k].parent;
        }
        codes[i] = (char *) malloc((n - j) * sizeof(char));
        strcpy(codes[i], &code[j + 1]);
    }
    free(code);
}

int main()
{
    int n = 8;
    HuffmanNode nodes[2 * n - 1];
    char *codes[n];
    int i;
    createHuffmanTree(nodes, n);
    createHuffmanCode(nodes, n, codes);
    printf("字符\t权值\t哈夫曼编码\n");
    for (i = 0; i < n; i++) {
        printf("%c\t%d\t%s\n", nodes[i].ch, nodes[i].weight, codes[i]);
    }
    for (i = 0; i < n; i++) {
        free(codes[i]);
    }
    return 0;
}

输出结果：

字符    权值    哈夫曼编码
A       5       1111
B       29      00
C       7       1110
D       8       1101
E       14      101
F       23      01
G       3       1100
H       11      100