用C语言写一个基于行程编码的图片压缩算法

行程编码（Run-length Encoding，简称RLE）是一种无损压缩算法，通常用于压缩连续且重复的数据。在图片中，有许多连续重复的像素，因此RLE算法可以有效地压缩图片数据。

下面是一个基于行程编码的图片压缩算法的C语言实现：

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

typedef struct RLE {
    int count;  // 连续重复像素的数量
    int value;  // 重复的像素值
} RLE;

// 压缩函数
int RLE_compress(unsigned char *input, int size, RLE **output) {
    int i, j, k;
    int count = 1;
    int value = input[0];
    int output_size = 0;
    RLE *rle = NULL;

    // 统计连续重复像素的数量和值
    for (i = 1; i < size; i++) {
        if (input[i] == value) {
            count++;
        } else {
            // 将连续重复像素的数量和值存储到RLE结构体中
            rle = (RLE *)realloc(rle, (output_size + 1) * sizeof(RLE));
            rle[output_size].count = count;
            rle[output_size].value = value;
            output_size++;

            value = input[i];
            count = 1;
        }
    }

    // 处理最后一段连续重复像素
    rle = (RLE *)realloc(rle, (output_size + 1) * sizeof(RLE));
    rle[output_size].count = count;
    rle[output_size].value = value;
    output_size++;

    // 将压缩结果存储到输出参数中
    *output = rle;

    return output_size;
}

// 解压函数
void RLE_decompress(RLE *input, int size, unsigned char **output) {
    int i, j, k;
    int output_size = 0;
    unsigned char *data = NULL;

    // 计算解压后的数据总长度
    for (i = 0; i < size; i++) {
        output_size += input[i].count;
    }

    // 分配解压后的数据空间
    data = (unsigned char *)malloc(output_size * sizeof(unsigned char));

    // 解压数据
    k = 0;
    for (i = 0; i < size; i++) {
        for (j = 0; j < input[i].count; j++) {
            data[k++] = input[i].value;
        }
    }

    // 将解压后的数据存储到输出参数中
    *output = data;
}

int main() {
    unsigned char input[] = {255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 255};
    int input_size = sizeof(input) / sizeof(unsigned char);
    RLE *output_rle = NULL;
    unsigned char *output_data = NULL;
    int output_size;

    // 压缩数据
    output_size = RLE_compress(input, input_size, &output_rle);

    // 解压数据
    RLE_decompress(output_rle, output_size, &output_data);

    // 打印压缩前后的数据
    printf("Original data: ");
    for (int i = 0; i < input_size; i++) {
        printf("%d ", input[i]);
    }
    printf("\n");

    printf("Compressed data: ");
    for (int i = 0; i < output_size; i++) {
        printf("(%d,%d) ", output_rle[i].count, output_rle[i].value);
    }
    printf("\n");

    printf("Decompressed data: ");
    for (int i = 0; i < input_size; i++) {
        printf("%d ", output_data[i]);
    }
    printf("\n");

    free(output_rle);
    free(output_data);

    return 0;
}

该算法的思路是先将连续重复像素的数量和值存储到一个RLE结构体中，然后再将RLE结构体序列存储到输出参数中。解压时，只需遍历RLE结构体序列，将连续重复像素解压即可。

在上述示例中，我们将一个长度为13的图像数据压缩成了长度为3的RLE结构体序列，并成功地将其解压回原始数据。