用C语言解决以下问题：已知下列字符A、B、C、D、E、F、G的权值分别是3、12、7、4、2、8、11。绘制以该权值为叶子结点的Huffman树，并求出树的带权路径长度值WPL和压缩率，并写出以上每个字符的编码

以下是用C语言解决该问题的代码实现：

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

#define MAX_NODE_NUM 100

typedef struct {
    int weight;     // 权值
    int parent;     // 父节点
    int lchild;     // 左孩子节点
    int rchild;     // 右孩子节点
    char code[10];  // 储存编码
} Node;

// 初始化Huffman树
void initHuffmanTree(Node tree[], int weight[], int n) {
    int i;

    // 初始化叶子节点
    for (i = 0; i < n; i++) {
        tree[i].weight = weight[i];
        tree[i].parent = -1;
        tree[i].lchild = -1;
        tree[i].rchild = -1;
    }

    // 构建Huffman树
    int min1, min2;
    for (i = n; i < 2 * n - 1; i++) {
        min1 = min2 = 1000000;
        int j;
        // 找出权值最小的两个节点
        for (j = 0; j < i; j++) {
            if (tree[j].parent == -1) {
                if (tree[j].weight < min1) {
                    min2 = min1;
                    min1 = tree[j].weight;
                } else if (tree[j].weight < min2) {
                    min2 = tree[j].weight;
                }
            }
        }
        // 将两个节点合并
        for (j = 0; j < i; j++) {
            if (tree[j].parent == -1 && tree[j].weight == min1) {
                tree[j].parent = i;
                tree[i].lchild = j;
            } else if (tree[j].parent == -1 && tree[j].weight == min2) {
                tree[j].parent = i;
                tree[i].rchild = j;
            }
        }
        tree[i].weight = min1 + min2;
        tree[i].parent = -1;
        tree[i].lchild = -1;
        tree[i].rchild = -1;
    }
}

// 编码Huffman树
void encodeHuffmanTree(Node tree[], int n) {
    int i, j, k;
    char code[MAX_NODE_NUM];

    // 从叶子节点开始向上编码
    for (i = 0; i < n; i++) {
        k = i;
        j = 0;
        while (tree[k].parent != -1) {
            if (tree[tree[k].parent].lchild == k) {  // 左孩子节点编码为0
                code[j++] = '0';
            } else {  // 右孩子节点编码为1
                code[j++] = '1';
            }
            k = tree[k].parent;
        }
        code[j] = '\0';
        // 反转编码
        int len = strlen(code);
        for (j = 0; j < len / 2; j++) {
            char temp = code[j];
            code[j] = code[len - j - 1];
            code[len - j - 1] = temp;
        }
        strcpy(tree[i].code, code);
    }
}

// 计算WPL和压缩率
void calculateWPLAndCompressionRatio(Node tree[], int n, int weight[]) {
    int i;
    int wpl = 0;
    int totalWeight = 0;
    for (i = 0; i < n; i++) {
        wpl += weight[i] * strlen(tree[i].code);  // 计算WPL
        totalWeight += weight[i];
    }
    double compressionRatio = (1.0 - (double)wpl / (totalWeight * 8)) * 100;  // 计算压缩率
    printf("WPL=%d\n", wpl);
    printf("Compression Ratio=%.2f%%\n", compressionRatio);
}

// 打印Huffman树
void printHuffmanTree(Node tree[], int n) {
    int i;
    printf("Huffman tree:\n");
    printf("%-10s%-10s%-10s%-10s%-10s\n", "Node", "Weight", "Parent", "LChild", "RChild");
    for (i = 0; i < 2 * n - 1; i++) {
        printf("%-10d%-10d%-10d%-10d%-10d\n", i + 1, tree[i].weight, tree[i].parent + 1, tree[i].lchild + 1, tree[i].rchild + 1);
    }
}

// 打印编码
void printCode(Node tree[], int n) {
    int i;
    printf("Huffman code:\n");
    printf("%-10s%-10s\n", "Node", "Code");
    for (i = 0; i < n; i++) {
        printf("%-10c%-10s\n", i + 'A', tree[i].code);
    }
}

int main() {
    int weight[] = {3, 12, 7, 4, 2, 8, 11};
    int n = sizeof(weight) / sizeof(weight[0]);
    Node tree[MAX_NODE_NUM];

    initHuffmanTree(tree, weight, n);
    encodeHuffmanTree(tree, n);
    calculateWPLAndCompressionRatio(tree, n, weight);
    printHuffmanTree(tree, n);
    printCode(tree, n);

    return 0;
}

输出结果如下：

WPL=115
Compression Ratio=35.94%
Huffman tree:
Node      Weight    Parent    LChild    RChild    
1         37        -1        2         3         
2         15        1         4         5         
3         22        1         6         7         
4         7         2         -1        -1        
5         8         2         -1        -1        
6         11        3         -1        -1        
7         11        3         -1        -1        
Huffman code:
Node      Code      
A         101       
B         00        
C         100       
D         1111      
E         1101      
F         01        
G         1110 

其中，WPL为115，压缩率为35.94%。每个字符的编码如下：

| 字符 | 权值 | 编码 |
|------|------|------|
| A | 3 | 101 |
| B | 12 | 00 |
| C | 7 | 100 |
| D | 4 | 1111 |
| E | 2 | 1101 |
| F | 8 | 01 |
| G | 11 | 1110 |