假设用于通信的电文仅由8个字母 {a, b, c, d, e, f, g, h} 构成，它们在电文中出现的概率分别为{ 0.07, 0.19, 0.02, 0.06, 0.32, 0.03, 0.21, 0.10 }，试为这8个字母设计哈夫曼编码，用C语言实现，使用顺序存储结构

哈夫曼编码的设计步骤如下：

1. 将所有字母按照出现概率从小到大排序。

2. 将概率最小的两个字母作为叶子节点，构造一棵二叉树，其根节点的权值为这两个字母出现概率之和。

3. 将这棵二叉树作为一个新的节点，其左子树和右子树分别是步骤2中的两个字母的二叉树。新节点的权值为这两个字母出现概率之和。

4. 重复步骤2和步骤3，直到所有叶子节点都被合并成一个节点为止。最终得到的二叉树即为哈夫曼树。

5. 从根节点开始，对于左子树分配编码“0”，对于右子树分配编码“1”，直到所有叶子节点都被编码。

根据上述步骤，我们可以得到8个字母的哈夫曼编码如下：

a: 1111
b: 10
c: 110111
d: 1110
e: 0
f: 110110
g: 11
h: 1100

下面是用C语言实现上述步骤的代码，使用顺序存储结构：

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

#define MAX_SIZE 100    // 最大节点数

// 定义节点结构体
typedef struct {
    char data;          // 节点存储的字符
    double weight;      // 字符出现概率
    int parent;         // 父节点下标
    int lchild;         // 左子树下标
    int rchild;         // 右子树下标
} HTNode;

// 构造哈夫曼树
void CreateHT(HTNode ht[], int n) {
    int i, j, k;
    double min1, min2;
    int p1, p2;
    for (i = 0; i < 2 * n - 1; i++) {
        ht[i].parent = ht[i].lchild = ht[i].rchild = -1;
    }
    for (i = n; i < 2 * n - 1; i++) {
        min1 = min2 = 1e9;
        p1 = p2 = -1;
        for (j = 0; j < i; j++) {
            if (ht[j].parent == -1) {   // 只考虑未被合并的节点
                if (ht[j].weight < min1) {
                    min2 = min1;
                    p2 = p1;
                    min1 = ht[j].weight;
                    p1 = j;
                } else if (ht[j].weight < min2) {
                    min2 = ht[j].weight;
                    p2 = j;
                }
            }
        }
        ht[p1].parent = i;
        ht[p2].parent = i;
        ht[i].lchild = p1;
        ht[i].rchild = p2;
        ht[i].weight = min1 + min2;
    }
}

// 获取哈夫曼编码
void GetHuffmanCode(HTNode ht[], int n, char *huffmanCode[]) {
    int i, j, c;
    char *code = (char *)malloc(n * sizeof(char));    // 临时存储编码
    code[n - 1] = '\0';     // 结尾字符
    for (i = 0; i < n; i++) {
        c = i;
        j = n - 1;
        while (ht[c].parent != -1) {    // 从叶子节点往上走到根节点
            if (ht[ht[c].parent].lchild == c) {
                code[--j] = '0';
            } else {
                code[--j] = '1';
            }
            c = ht[c].parent;
        }
        huffmanCode[i] = (char *)malloc((n - j) * sizeof(char));    // 分配对应的编码空间
        strcpy(huffmanCode[i], &code[j]);    // 复制编码
    }
    free(code);
}

int main() {
    char data[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
    double weight[] = {0.07, 0.19, 0.02, 0.06, 0.32, 0.03, 0.21, 0.10};
    int n = sizeof(data) / sizeof(data[0]);
    HTNode ht[MAX_SIZE];
    int i;
    for (i = 0; i < n; i++) {
        ht[i].data = data[i];
        ht[i].weight = weight[i];
    }
    CreateHT(ht, n);
    char *huffmanCode[MAX_SIZE];
    GetHuffmanCode(ht, n, huffmanCode);
    printf("Huffman codes:\n");
    for (i = 0; i < n; i++) {
        printf("%c: %s\n", ht[i].data, huffmanCode[i]);
    }
    return 0;
}