用香农熵编码压缩图像c语言

使用香农熵编码压缩图像需要按照以下步骤进行实现：

1. 加载图像数据，将每个像素的颜色值转换为字符。
2. 统计每个字符在图像中出现的频率，计算香农熵。
3. 构建哈夫曼树，根据字符出现的频率生成哈夫曼编码。
4. 对图像数据进行编码，将每个字符替换为它对应的哈夫曼编码。
5. 将编码后的数据保存。

下面是一个简单的 C 语言实现：

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

#define MAX_CHAR 256
#define MAX_TREE 512

struct node {
    int freq;
    char c;
    struct node *left, *right;
};

struct node *new_node(int freq, char c) {
    struct node *n = (struct node*) malloc(sizeof(struct node));
    n->freq = freq;
    n->c = c;
    n->left = n->right = NULL;
    return n;
}

void swap(struct node **a, struct node **b) {
    struct node *t = *a;
    *a = *b;
    *b = t;
}

void heapify(struct node **arr, int n, int i) {
    int smallest = i;
    int l = 2 * i + 1;
    int r = 2 * i + 2;
    
    if (l < n && arr[l]->freq < arr[smallest]->freq) {
        smallest = l;
    }
    
    if (r < n && arr[r]->freq < arr[smallest]->freq) {
        smallest = r;
    }
    
    if (smallest != i) {
        swap(&arr[i], &arr[smallest]);
        heapify(arr, n, smallest);
    }
}

struct node *build_tree(char *s, int *freq) {
    struct node *arr[MAX_TREE];
    int n = 0;
    
    for (int i = 0; i < MAX_CHAR; i++) {
        if (freq[i] > 0) {
            arr[n++] = new_node(freq[i], i);
        }
    }
    
    while (n > 1) {
        struct node *left = arr[n - 1];
        struct node *right = arr[n - 2];
        struct node *parent = new_node(left->freq + right->freq, 0);
        parent->left = left;
        parent->right = right;
        arr[n - 2] = parent;
        n--;
        heapify(arr, n, 0);
    }
    
    return arr[0];
}

void encode_tree(struct node *root, char *code, char **table) {
    if (root->left != NULL) {
        code[strlen(code)] = '0';
        encode_tree(root->left, code, table);
    }
    
    if (root->right != NULL) {
        code[strlen(code)] = '1';
        encode_tree(root->right, code, table);
    }
    
    if (root->left == NULL && root->right == NULL) {
        table[root->c] = (char*) malloc(strlen(code) + 1);
        strcpy(table[root->c], code);
    }
    
    code[strlen(code) - 1] = '\0';
}

void encode_data(char *s, char **table, char *code) {
    for (int i = 0; i < strlen(s); i++) {
        strcat(code, table[s[i]]);
    }
}

void write_data(char *data, char *filename) {
    FILE *fp = fopen(filename, "wb");
    fwrite(data, sizeof(char), strlen(data), fp);
    fclose(fp);
}

int main() {
    char *filename = "input.bmp";
    FILE *fp = fopen(filename, "rb");
    
    if (fp == NULL) {
        printf("File not found!\n");
        return 1;
    }
    
    int freq[MAX_CHAR] = {0};
    char buf;
    
    while (fread(&buf, sizeof(char), 1, fp)) {
        freq[buf]++;
    }
    
    fclose(fp);
    
    struct node *root = build_tree(NULL, freq);
    char code[MAX_CHAR] = "";
    char *table[MAX_CHAR] = {NULL};
    encode_tree(root, code, table);
    
    fp = fopen(filename, "rb");
    char data[MAX_CHAR] = "";
    
    while (fread(&buf, sizeof(char), 1, fp)) {
        strcat(data, table[buf]);
    }
    
    fclose(fp);
    write_data(data, "output.dat");
    
    return 0;
}

需要注意的是，这个实现只能处理 ASCII 字符集，如果要处理其他字符集，需要修改代码。此外，解压缩也需要使用相应的算法，这里不再赘述。