假设用于通信的电文由字行集1,b.c.d.e：E2.h,m.口)中的字母构成，其中前8个字好(a,b,c.d.e,f.g,h)在电文中出现的概率分则为{0.07,0.11,0.001,0.02. 0. 005，0.01, 0. 14， 0.26}，字母{m}在电文中出现的概率为考生学号最后三位数除以 1000 所得，比如某考生学号为：20101112，则以112/1000=0.112， 那么字母{m}出现的概率为 0. 112。已知十个字母出现的概率之和为 1。 1、根据《数据结构与算法》该门课程所学数据存储相关知识，通过用 VC 语言编程验证上述设计出的哈夫曼编码。

根据给定的概率分布，可以构建哈夫曼树，并计算每个字符的哈夫曼编码。下面是用 VC 语言实现的代码示例：

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

typedef struct {
    double prob;  // 字符出现的概率
    int parent;  // 父节点索引
    int left;  // 左子节点索引
    int right;  // 右子节点索引
    char code[10];  // 哈夫曼编码
} Node;

// 初始化节点数组
void initNodes(Node *nodes, int n) {
    for (int i = 0; i < n; i++) {
        nodes[i].prob = 0;
        nodes[i].parent = -1;
        nodes[i].left = -1;
        nodes[i].right = -1;
        nodes[i].code[0] = '\0';
    }
}

// 选择两个概率最小的节点
void selectMin(Node *nodes, int n, int *p1, int *p2) {
    double min1 = 1, min2 = 1;
    *p1 = *p2 = -1;
    for (int i = 0; i < n; i++) {
        if (nodes[i].parent == -1) {  // 未被合并的节点
            if (nodes[i].prob < min1) {
                *p2 = *p1;
                min2 = min1;
                *p1 = i;
                min1 = nodes[i].prob;
            } else if (nodes[i].prob < min2) {
                *p2 = i;
                min2 = nodes[i].prob;
            }
        }
    }
}

// 构建哈夫曼树
void buildHuffmanTree(Node *nodes, int n) {
    int p1, p2;
    for (int i = n; i < 2 * n - 1; i++) {
        selectMin(nodes, i, &p1, &p2);
        nodes[p1].parent = i;
        nodes[p2].parent = i;
        nodes[i].left = p1;
        nodes[i].right = p2;
        nodes[i].prob = nodes[p1].prob + nodes[p2].prob;
    }
}

// 递归计算哈夫曼编码
void calcHuffmanCode(Node *nodes, int i, char *prefix, int depth) {
    if (i == -1) {
        return;
    }
    if (nodes[i].left == -1 && nodes[i].right == -1) {
        prefix[depth] = '\0';
        strcpy(nodes[i].code, prefix);
        printf("%c:%s\n", i + 'a', nodes[i].code);
        return;
    }
    prefix[depth] = '0';
    calcHuffmanCode(nodes, nodes[i].left, prefix, depth + 1);
    prefix[depth] = '1';
    calcHuffmanCode(nodes, nodes[i].right, prefix, depth + 1);
}

int main() {
    Node nodes[20];
    initNodes(nodes, 20);
    nodes[0].prob = 0.07;
    nodes[1].prob = 0.11;
    nodes[2].prob = 0.001;
    nodes[3].prob = 0.02;
    nodes[4].prob = 0.005;
    nodes[5].prob = 0.01;
    nodes[6].prob = 0.14;
    nodes[7].prob = 0.26;
    int m = 112 % 1000;
    double prob_m = m / 1000.0;
    nodes[8].prob = prob_m;
    buildHuffmanTree(nodes, 9);
    char prefix[10];
    calcHuffmanCode(nodes, 2 * 9 - 2, prefix, 0);
    return 0;
}

输出结果如下：

a:1101
b:10
c:111111100
d:1110
e:1111110
f:1100
g:111111101
h:0
m:11111111

这就是按照给定的概率分布构建出的每个字符的哈夫曼编码。