【PTA数据结构 | C语言版】对二进制字符串解码

本专栏持续输出数据结构题目集，欢迎订阅。

题目

请编写程序，根据给定的字符和权重值序列，构建哈夫曼树，并将输入的二进制字符串解码输出。

注意：因为哈夫曼编码是不唯一的，所以如果不严格按照指定方法生成哈夫曼树，则有可能无法正确解码。本题规定的哈夫曼树构建限制为：

• 哈夫曼森林的所有根结点存为线性表，新的树根必须插入表头；
• 每次取出权值最小的根结点时，若有并列，取最靠近表头的那个；
• 对于每轮取出的两个根结点，第一个取出的为左子树，第二个取出的为右子树；
• 二进制字符 0 对应树中的左分支；1 对应右分支。

输入格式：
输入首先给出一个正整数 n（1<n≤20），随后 n 行，每行给出一个字符及其权重值，其间以空格分隔。其中字符为小写英文字母，权重值都是不超过 100 的正整数。最后一行给出一个由 0 和 1 组成的二进制字符串，长度不超过 1000，以回车结束。题目保证这个字符串有唯一解码。

输出格式：
在一行中输出解码后的字符串。

输入样例：
5
a 4
b 3
c 2
w 1
z 1
100001110101101101100111

输出样例：
baaacabwbzc

样例说明：
按照本题构建哈夫曼树的规定，生成的哈夫曼编码如下：
a 0
b 10
c 111
z 1100
w 1101

代码

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

// 定义树节点结构
typedef struct TreeNode {
    char data;          // 存储字符（叶子节点有效）
    int weight;         // 节点权重
    struct TreeNode *left, *right;  // 左右子树指针
} TreeNode;

// 定义森林结构
typedef struct {
    TreeNode **nodes;   // 存储树节点指针的数组
    int size;           // 当前森林中的树数量
} Forest;

// 创建新的树节点并初始化
TreeNode* createNode(char data, int weight) {
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    node->data = data;
    node->weight = weight;
    node->left = node->right = NULL;
    return node;
}

// 创建森林并分配内存
Forest* createForest(int capacity) {
    Forest* forest = (Forest*)malloc(sizeof(Forest));
    forest->nodes = (TreeNode**)malloc(capacity * sizeof(TreeNode*));
    forest->size = 0;
    return forest;
}

// 将新节点插入到森林的表头位置
void insertNode(Forest* forest, TreeNode* node) {
    // 将所有现有节点后移一位
    for (int i = forest->size; i > 0; i--) {
        forest->nodes[i] = forest->nodes[i-1];
    }
    forest->nodes[0] = node;  // 新节点插入表头
    forest->size++;
}

// 从森林中提取权重最小的节点
TreeNode* extractMin(Forest* forest) {
    if (forest->size == 0) return NULL;
    int minIdx = 0;  // 记录最小权重节点的索引
    
    // 遍历寻找最小权重节点（相同权重时取最前的节点）
    for (int i = 1; i < forest->size; i++) {
        if (forest->nodes[i]->weight < forest->nodes[minIdx]->weight) {
            minIdx = i;
        }
    }
    
    TreeNode* minNode = forest->nodes[minIdx];
    
    // 删除最小节点并前移后续节点
    for (int i = minIdx; i < forest->size - 1; i++) {
        forest->nodes[i] = forest->nodes[i+1];
    }
    forest->size--;
    return minNode;
}

// 构建哈夫曼树
TreeNode* buildHuffmanTree(int n) {
    Forest* forest = createForest(n);
    
    // 读取输入字符和权重，创建节点并插入森林
    for (int i = 0; i < n; i++) {
        char data;
        int weight;
        scanf(" %c %d", &data, &weight);
        TreeNode* node = createNode(data, weight);
        insertNode(forest, node);
    }

    // 循环合并最小的两棵树，直到森林中只剩一棵树
    while (forest->size > 1) {
        // 取出两个最小权重节点
        TreeNode* left = extractMin(forest);
        TreeNode* right = extractMin(forest);
        
        // 创建父节点，权重为两子节点之和
        TreeNode* parent = createNode('\0', left->weight + right->weight);
        parent->left = left;  // 第一个取出的节点作为左子树
        parent->right = right;  // 第二个取出的节点作为右子树
        
        // 将新树插入森林表头
        insertNode(forest, parent);
    }

    // 取出最终的哈夫曼树根节点并释放森林内存
    TreeNode* root = extractMin(forest);
    free(forest->nodes);
    free(forest);
    return root;
}

// 根据哈夫曼树解码二进制字符串
void decode(TreeNode* root, char* encoded) {
    TreeNode* current = root;  // 从根节点开始解码
    
    for (int i = 0; encoded[i] != '\0'; i++) {
        // 根据二进制字符选择左/右子树
        if (encoded[i] == '0') {
            current = current->left;  // '0'表示左分支
        } else {
            current = current->right; // '1'表示右分支
        }
        
        // 到达叶子节点时输出字符并重置到根节点
        if (current->left == NULL && current->right == NULL) {
            printf("%c", current->data);
            current = root;  // 回到根节点继续解码
        }
    }
    printf("\n");
}

int main() {
    int n;
    scanf("%d", &n);
    
    // 构建哈夫曼树
    TreeNode* root = buildHuffmanTree(n);
    
    // 读取待解码的二进制字符串
    char encoded[1001];
    scanf("%s", encoded);
    
    // 解码并输出结果
    decode(root, encoded);
    
    return 0;
}