用c语言写一个代码，输入一串字符串，根据给定的字符串中字符出现的频率建立相应的哈夫曼树，构造哈夫曼编码表，在此基础上可以对压缩文件进行压缩，同时可以对压缩后的二进制编码文件进行解压

好的，以下是一个基于C语言的实现，实现了输入字符串后建立哈夫曼树，并构造哈夫曼编码表的功能。同时也提供了对压缩文件进行压缩和解压缩的功能。注意，以下代码仅供参考，实际使用时可能需要根据具体场景进行修改和完善。 ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdbool.h> #include <stdint.h> #define MAX_LEN 256 typedef struct HuffmanNode { char val; int freq; struct HuffmanNode* left; struct HuffmanNode* right; } HuffmanNode; typedef struct CodeTable { char ch; char* code; } CodeTable; CodeTable code_table[MAX_LEN]; int code_table_size = 0; void print_code_table() { printf("Huffman code table:\n"); for (int i = 0; i < code_table_size; i++) { printf("%c: %s\n", code_table[i].ch, code_table[i].code); } } void free_huffman_tree(HuffmanNode* root) { if (root) { free_huffman_tree(root->left); free_huffman_tree(root->right); free(root); } } int cmp_node(const void* a, const void* b) { HuffmanNode* node1 = *(HuffmanNode**)a; HuffmanNode* node2 = *(HuffmanNode**)b; return node1->freq - node2->freq; } void build_huffman_tree(char* s, int n, HuffmanNode** root) { int freq[MAX_LEN] = {0}; for (int i = 0; i < n; i++) { freq[s[i]]++; } HuffmanNode* nodes[MAX_LEN]; int nodes_size = 0; for (int i = 0; i < MAX_LEN; i++) { if (freq[i] > 0) { nodes[nodes_size] = (HuffmanNode*)malloc(sizeof(HuffmanNode)); nodes[nodes_size]->val = i; nodes[nodes_size]->freq = freq[i]; nodes[nodes_size]->left = NULL; nodes[nodes_size]->right = NULL; nodes_size++; } } while (nodes_size > 1) { qsort(nodes, nodes_size, sizeof(HuffmanNode*), cmp_node); HuffmanNode* node1 = nodes[0]; HuffmanNode* node2 = nodes[1]; HuffmanNode* merged_node = (HuffmanNode*)malloc(sizeof(HuffmanNode)); merged_node->val = -1; merged_node->freq = node1->freq + node2->freq; merged_node->left = node1; merged_node->right = node2; nodes[0] = merged_node; nodes_size--; for (int i = 1; i < nodes_size; i++) { nodes[i] = nodes[i + 1]; } } *root = nodes[0]; } void dfs_huffman_tree(HuffmanNode* root, char* code, int len) { if (root->val != -1) { CodeTable ct = {root->val, (char*)malloc((len + 1) * sizeof(char))}; strcpy(ct.code, code); code_table[code_table_size] = ct; code_table_size++; } if (root->left) { code[len] = '0'; dfs_huffman_tree(root->left, code, len + 1); } if (root->right) { code[len] = '1'; dfs_huffman_tree(root->right, code, len + 1); } } void build_huffman_code_table(HuffmanNode* root) { char code[MAX_LEN] = {0}; dfs_huffman_tree(root, code, 0); } int get_bit(uint8_t byte, int i) { return (byte >> (7 - i)) & 1; } void compress_file(char* src_file, char* dst_file) { FILE* fp_src = fopen(src_file, "rb"); if (!fp_src) { printf("Error: cannot open source file!\n"); return; } FILE* fp_dst = fopen(dst_file, "wb"); if (!fp_dst) { printf("Error: cannot open destination file!\n"); fclose(fp_src); return; } // Count frequency int freq[MAX_LEN] = {0}; char ch; while (fread(&ch, sizeof(char), 1, fp_src) == 1) { freq[ch]++; } rewind(fp_src); // Build Huffman tree HuffmanNode* root = NULL; build_huffman_tree(NULL, MAX_LEN, &root); free_huffman_tree(root); build_huffman_tree(NULL, MAX_LEN, &root); // Build Huffman code table code_table_size = 0; build_huffman_code_table(root); // Write Huffman code table to file fwrite(&code_table_size, sizeof(int), 1, fp_dst); for (int i = 0; i < code_table_size; i++) { fwrite(&code_table[i].ch, sizeof(char), 1, fp_dst); int code_len = strlen(code_table[i].code); fwrite(&code_len, sizeof(int), 1, fp_dst); fwrite(code_table[i].code, sizeof(char), code_len, fp_dst); } // Compress data and write to file uint8_t byte = 0; int bit_count = 0; while (fread(&ch, sizeof(char), 1, fp_src) == 1) { char* code = NULL; for (int i = 0; i < code_table_size; i++) { if (code_table[i].ch == ch) { code = code_table[i].code; break; } } int code_len = strlen(code); for (int i = 0; i < code_len; i++) { byte |= (code[i] - '0') << (7 - bit_count); bit_count++; if (bit_count == 8) { fwrite(&byte, sizeof(uint8_t), 1, fp_dst); byte = 0; bit_count = 0; } } } if (bit_count > 0) { fwrite(&byte, sizeof(uint8_t), 1, fp_dst); } fclose(fp_src); fclose(fp_dst); } void decompress_file(char* src_file, char* dst_file) { FILE* fp_src = fopen(src_file, "rb"); if (!fp_src) { printf("Error: cannot open source file!\n"); return; } FILE* fp_dst = fopen(dst_file, "wb"); if (!fp_dst) { printf("Error: cannot open destination file!\n"); fclose(fp_src); return; } // Read Huffman code table from file fread(&code_table_size, sizeof(int), 1, fp_src); for (int i = 0; i < code_table_size; i++) { fread(&code_table[i].ch, sizeof(char), 1, fp_src); int code_len; fread(&code_len, sizeof(int), 1, fp_src); code_table[i].code = (char*)malloc((code_len + 1) * sizeof(char)); fread(code_table[i].code, sizeof(char), code_len, fp_src); code_table[i].code[code_len] = '\0'; } // Build Huffman tree HuffmanNode* root = NULL; build_huffman_tree(NULL, MAX_LEN, &root); free_huffman_tree(root); build_huffman_tree(NULL, MAX_LEN, &root); // Decompress data and write to file HuffmanNode* current = root; uint8_t byte; while (fread(&byte, sizeof(uint8_t), 1, fp_src) == 1) { for (int i = 0; i < 8; i++) { int bit = get_bit(byte, i); if (bit == 0) { current = current->left; } else { current = current->right; } if (current->val != -1) { fwrite(&current->val, sizeof(char), 1, fp_dst); current = root; } } } fclose(fp_src); fclose(fp_dst); } int main() { char s[MAX_LEN]; printf("Please input a string:\n"); fgets(s, MAX_LEN, stdin); int n = strlen(s); if (s[n - 1] == '\n') { s[n - 1] = '\0'; n--; } // Build Huffman tree HuffmanNode* root = NULL; build_huffman_tree(s, n, &root); // Build Huffman code table code_table_size = 0; build_huffman_code_table(root); print_code_table(); // Compress data and write to file compress_file("input.txt", "output.bin"); // Decompress data and write to file decompress_file("output.bin", "output.txt"); free_huffman_tree(root); return 0; } ```