假设用于通信的电文仅由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. 将新节点插入到原序列中，保持有序性。

4. 重复步骤2和3，直到只剩下一个节点。

5. 从叶子节点到根节点，对每个节点标记一个0或1，表示左儿子或右儿子。

6. 标记完毕后，从根节点到叶子节点，依次记录下每个字符对应的编码。

下面是用C语言实现哈夫曼编码的示例代码：

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

#define MAX_CHARACTERS 8

struct node {
    char character;
    float probability;
    struct node *left;
    struct node *right;
};

struct code {
    char character;
    char bits[MAX_CHARACTERS];
};

void sort(struct node **nodes, int count) {
    int i, j;
    for (i = 0; i < count; i++) {
        for (j = i + 1; j < count; j++) {
            if (nodes[i]->probability > nodes[j]->probability) {
                struct node *temp = nodes[i];
                nodes[i] = nodes[j];
                nodes[j] = temp;
            }
        }
    }
}

struct node *merge(struct node *a, struct node *b) {
    struct node *node = malloc(sizeof(struct node));
    node->probability = a->probability + b->probability;
    node->left = a;
    node->right = b;
    return node;
}

void print_code(struct code *codes, int count) {
    int i;
    for (i = 0; i < count; i++) {
        printf("%c: %s\n", codes[i].character, codes[i].bits);
    }
}

void encode(struct node *node, struct code *codes, char *bits, int length) {
    if (node->left == NULL && node->right == NULL) {
        int i;
        for (i = 0; i < length; i++) {
            codes[node->character].bits[i] = bits[i];
        }
        codes[node->character].bits[length] = '\0';
        return;
    }
    bits[length] = '0';
    encode(node->left, codes, bits, length + 1);
    bits[length] = '1';
    encode(node->right, codes, bits, length + 1);
}

int main() {
    char characters[MAX_CHARACTERS] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
    float probabilities[MAX_CHARACTERS] = {0.07, 0.19, 0.02, 0.06, 0.32, 0.03, 0.21, 0.10};
    int count = MAX_CHARACTERS;
    struct node *nodes[MAX_CHARACTERS];
    int i;
    for (i = 0; i < count; i++) {
        nodes[i] = malloc(sizeof(struct node));
        nodes[i]->character = characters[i];
        nodes[i]->probability = probabilities[i];
        nodes[i]->left = NULL;
        nodes[i]->right = NULL;
    }
    while (count > 1) {
        sort(nodes, count);
        struct node *a = nodes[0];
        struct node *b = nodes[1];
        nodes[0] = merge(a, b);
        int j;
        for (j = 1; j < count - 1; j++) {
            nodes[j] = nodes[j + 1];
        }
        count--;
    }
    struct code codes[MAX_CHARACTERS];
    char bits[MAX_CHARACTERS];
    encode(nodes[0], codes, bits, 0);
    print_code(codes, MAX_CHARACTERS);
    return 0;
}

输出如下：

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

其中，每个字符对应的编码存储在`struct code`的`bits`字段中。