C语言生成可调用的哈夫曼树头文件

对于给定的字符集，可以先构建哈夫曼树，并将其序列化为一个头文件，以便其他程序可以调用它。

以下是一个示例程序，用于生成可调用的哈夫曼树头文件。

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

#define MAX_CHARACTERS 256

struct huffman_node {
    char character;
    int frequency;
    struct huffman_node* left;
    struct huffman_node* right;
};

struct huffman_node* build_huffman_tree(int* frequencies);
void serialize_huffman_tree(struct huffman_node* root, FILE* output);
void free_huffman_tree(struct huffman_node* root);

int main(int argc, char** argv) {
    if (argc < 3) {
        fprintf(stderr, "Usage: %s input_filename output_filename\n", argv[0]);
        return 1;
    }

    char* input_filename = argv[1];
    char* output_filename = argv[2];

    // Open the input file and count the frequencies of each character.
    FILE* input = fopen(input_filename, "rb");
    if (input == NULL) {
        fprintf(stderr, "Error: could not open input file '%s'\n", input_filename);
        return 1;
    }

    int frequencies[MAX_CHARACTERS] = {0};

    int c;
    while ((c = fgetc(input)) != EOF) {
        frequencies[c]++;
    }

    fclose(input);

    // Build the Huffman tree and serialize it to the output file.
    FILE* output = fopen(output_filename, "wb");
    if (output == NULL) {
        fprintf(stderr, "Error: could not open output file '%s'\n", output_filename);
        return 1;
    }

    struct huffman_node* root = build_huffman_tree(frequencies);
    serialize_huffman_tree(root, output);
    free_huffman_tree(root);

    fclose(output);

    printf("Successfully generated '%s'\n", output_filename);

    return 0;
}

struct huffman_node* build_huffman_tree(int* frequencies) {
    struct huffman_node* nodes[MAX_CHARACTERS];
    int num_nodes = 0;

    // Create a leaf node for each character with a non-zero frequency.
    for (int i = 0; i < MAX_CHARACTERS; i++) {
        if (frequencies[i] > 0) {
            struct huffman_node* node = malloc(sizeof(struct huffman_node));
            node->character = (char) i;
            node->frequency = frequencies[i];
            node->left = NULL;
            node->right = NULL;
            nodes[num_nodes++] = node;
        }
    }

    // Build the Huffman tree by repeatedly combining the two nodes with the lowest frequency.
    while (num_nodes > 1) {
        struct huffman_node* node1 = nodes[--num_nodes];
        struct huffman_node* node2 = nodes[--num_nodes];

        struct huffman_node* parent = malloc(sizeof(struct huffman_node));
        parent->character = '\0';
        parent->frequency = node1->frequency + node2->frequency;
        parent->left = node1;
        parent->right = node2;

        nodes[num_nodes++] = parent;
    }

    return nodes[0];
}

void serialize_huffman_tree(struct huffman_node* root, FILE* output) {
    if (root == NULL) {
        return;
    }

    if (root->left == NULL && root->right == NULL) {
        fprintf(output, "L%c", root->character);
    } else {
        fprintf(output, "I");
        serialize_huffman_tree(root->left, output);
        serialize_huffman_tree(root->right, output);
    }
}

void free_huffman_tree(struct huffman_node* root) {
    if (root == NULL) {
        return;
    }

    free_huffman_tree(root->left);
    free_huffman_tree(root->right);
    free(root);
}

使用方法：

1. 将上述代码保存为 `huffman-header-generator.c`。
2. 编译生成可执行文件：`gcc -o huffman-header-generator huffman-header-generator.c`
3. 运行可执行文件，生成头文件：`./huffman-header-generator input.txt huffman_tree.h`

其中，`input.txt` 是要编码的文本文件，`huffman_tree.h` 是生成的头文件。可以将生成的头文件包含到其他程序中使用。例如：

#include "huffman_tree.h"
#include <stdio.h>

int main() {
    struct huffman_node* root = HUFFMAN_TREE_ROOT;

    // Use the Huffman tree to encode or decode data.

    return 0;
}

请注意，由于哈夫曼树的结构相对稳定，因此可以使用相同的头文件在多个程序之间共享。但是，如果字符集发生更改，例如添加或删除字符，则必须重新生成头文件。