帮我写一个c语言代码用于压缩字符串

好的，以下是一个简单的C语言代码用于压缩字符串：

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

int main()
{
    char str[100], compressed[100];
    int count = 1, j = 0;

    printf("请输入一个字符串：");
    scanf("%s", str);

    for (int i = 0; i < strlen(str); i++)
    {
        if (str[i] == str[i+1])
        {
            count++;
        }
        else
        {
            compressed[j++] = str[i];
            compressed[j++] = count + '0';
            count = 1;
        }
    }

    compressed[j] = '\0';

    printf("压缩后的字符串为：%s\n", compressed);

    return 0;
}

该代码会将输入的字符串进行压缩，例如输入"aaabbbccc"，输出" a3b3c3"。

相关问题

帮我写字符串压缩的c代码

当然可以，字符串压缩是一种常见的数据结构优化技巧，用于减少存储空间。这里是一个简单的LZW压缩算法的C语言实现示例，它不是标准的文本压缩算法，但可以作为基础理解：

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

#define TABLE_SIZE 256

// 定义LZW表
typedef struct {
    char data[TABLE_SIZE];
    int index[TABLE_SIZE];
} LZWTable;

// 创建新的LZW表
LZWTable* createLZWTable() {
    LZWTable *table = (LZWTable*)malloc(sizeof(LZWTable));
    memset(table->data, 0, TABLE_SIZE);
    for (int i = 0; i < TABLE_SIZE; ++i) {
        table->index[i] = i;
    }
    return table;
}

// 检查并返回对应字符的索引，如果不存在则添加到表中并返回新值
int findOrAdd(char c, LZWTable *table) {
    if (table->data[c] == 0) {
        table->data[c] = table->index[TABLE_SIZE - 1]++;
        return table->index[TABLE_SIZE - 1];
    }
    return table->data[c];
}

// 压缩字符串
void compressString(char input[], int compressed[], int *compressedLength, LZWTable *table) {
    int code = 0;
    int prevCode = 0;
    *compressedLength = 0;
    
    // 将输入字符串转换成连续的字符编码
    for (int i = 0; input[i]; ++i) {
        int currentCode = findOrAdd(input[i], table);
        if (currentCode != prevCode) { // 新的字符序列
            compressed[*compressedLength++] = prevCode << 1 | 1; // 添加前缀1表示开始一个新的序列
        }
        compressed[*compressedLength++] = currentCode; // 添加当前字符的编码
        prevCode = currentCode;
    }
    // 如果最后一个字符序列没变，不需要额外添加1
    if (prevCode != 0) {
        compressed[*compressedLength++] = prevCode << 1;
    }
}

int main() {
    char input[] = "abacabad";
    int compressed[length], compressedLength = 0;
    LZWTable *table = createLZWTable();

    compressString(input, compressed, &compressedLength, table);

    printf("Original String: %s\n", input);
    printf("Compressed String: ", "");
    for (int i = 0; i < compressedLength; ++i) {
        printf("%d", compressed[i]);
    }

    return 0;
}

这个例子中，我们首先创建了一个LZW表，然后遍历输入字符串，将相邻的重复字符序列替换为其对应的编码。注意这只是一个简化版的实现，并非高效的压缩算法。

帮我写一个LZW解压的C语言代码

好的，以下是一个简单的LZW解压缩代码，希望能帮到你：

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

#define MAX_TABLE_SIZE 4096

typedef struct {
    int prefix;
    char suffix;
} dictionary_entry;

dictionary_entry dictionary[MAX_TABLE_SIZE];

void init_dictionary() {
    for (int i = 0; i < 256; i++) {
        dictionary[i].prefix = -1;
        dictionary[i].suffix = i;
    }
}

void output(char *str, int len) {
    for (int i = 0; i < len; i++) {
        putchar(str[i]);
    }
}

void decompress(int *compressed_data, int compressed_size) {
    int prefix, suffix;
    char str[MAX_TABLE_SIZE];
    int index = 256;
    int length = 0;

    prefix = *compressed_data++;
    suffix = prefix;
    str[length++] = suffix;

    while (--compressed_size > 0) {
        prefix = *compressed_data++;

        if (prefix >= index) {
            str[length++] = suffix;
            str[length] = suffix;
        } else if (dictionary[prefix].prefix == -1) {
            str[length++] = dictionary[prefix].suffix;
            str[length] = dictionary[prefix].suffix;
        } else {
            int i = 0;
            int k = prefix;

            while (dictionary[k].prefix != -1) {
                str[i++] = dictionary[k].suffix;
                k = dictionary[k].prefix;
            }

            str[i++] = dictionary[k].suffix;

            while (i-- > 0) {
                putchar(str[i]);
            }

            str[length] = dictionary[k].suffix;
        }

        if (index < MAX_TABLE_SIZE) {
            dictionary[index].prefix = prefix;
            dictionary[index].suffix = str[length];
            index++;
        }

        suffix = str[length];
        length++;
    }
}

int main() {
    int compressed_data[] = {97, 98, 99, 256, 258, 257, 260, 262, 259, 261, 263};

    init_dictionary();

    decompress(compressed_data, sizeof(compressed_data) / sizeof(compressed_data[0]));

    return 0;
}

解释一下代码的大致流程：

1. 首先定义了一个结构体 `dictionary_entry`，用于表示字典表中的每个条目；
2. 然后定义了一个 `dictionary` 数组，用于存储字典表中的所有条目；
3. `init_dictionary` 函数用于初始化字典表，将前 256 个条目初始化为单个字节的字符；
4. `output` 函数用于输出解压缩后的字符串；
5. `decompress` 函数用于实现解压缩过程，输入为压缩后的数据和数据大小，输出为解压缩后的字符串；
6. `main` 函数中定义了一个测试用的压缩数据数组 `compressed_data`，然后调用 `init_dictionary` 函数进行初始化，最后调用 `decompress` 函数进行解压缩，并输出解压缩后的字符串。

希望这个简单的代码能够帮到你。