游程编码(Run-Length Encoding, RLE)的python实现

游程编码(Run-Length Encoding, RLE)的python实现

基本原理及步骤

游程编码(Run-Length Encoding, RLE)，是一种简单的无损数据压缩方法，通过计数连续出现的字符来压缩数据。

主要思想是遍历输入源数据，计算连续相同字符的数量，并在字符发生变化时输出当前的计数和字符。每次字符发生变化时，都会输出一个元组，格式为(字符, 计数)，最后返回的是最后一个字符的计数和字符。

RLE特别适合于包含大量重复数据的数据集，例如简单的图形图像或文本文件，其中可能有长串的空格或相同的字符。

Run-Length Encoding (RLE) 是一种简单的无损数据压缩算法，它通过计数连续出现的相同数据元素来压缩数据。RLE特别适合于包含大量重复数据的数据集，例如简单的图形图像或文本文件，其中可能有长串的空格或相同的字符。
上述代码实现RLE编码的原理如下：

1. 初始化计数器：
   • 设置一个计数器count，用于记录当前字符重复的次数。初始值为1，因为至少有一个字符。
2. 遍历数据：
   • 从数据的第二个字符开始遍历，比较当前字符与前一个字符。
3. 计数连续相同的字符：
   • 如果当前字符与前一个字符相同，增加计数器count。
   • 如果当前字符与前一个字符不同，输出前一个字符的计数和字符本身，然后将计数器重置为1。
4. 输出编码结果：
   • 每当遇到一个不同的字符时，输出一个元组，格式为(字符, 计数)。
   • 最后，输出最后一个字符的计数和字符。
5. 返回编码结果：
   • 将所有输出的元组组合起来，形成编码后的字符串。

RLE编码的关键在于它能够减少表示重复数据所需的空间。例如，字符串"AAAABBBCCDAA"可以被编码为"(4,A)(3,B)(2,C)(1,D)(2,A)"，这样可以显著减少数据的大小，特别是当有长串的重复字符时。

Python实现

编码

# 方法一：
def run_length_encode1(data, _format="tuple"):
    rel_list = []
    count = 1
    for i in range(0, len(data)):
        if i + 1 < len(data) and data[i] == data[i + 1]:
            count += 1
        else:
            rel_list.append(data[i])
            rel_list.append(count)
            count = 1
    if _format == "list":
        return rel_list

    if _format == "tuple":
        buf = ""
        for index, value in enumerate(rel_list):
            if index % 2 == 0:
                buf += "(" + str(value) + ","
            else:
                buf += str(value) + "),"

        return buf.rstrip(",")


# 方法二:
def run_length_encode2(data):
    """
    实现游程编码。
    :param data: 待编码的字符串
    :return: 压缩后的字符串
    """
    if not data:
        return ""

    encoded_string = ""
    count = 1
    prev_char = data[0]

    for i in range(1, len(data)):
        if data[i] == prev_char:
            count += 1
        else:
            encoded_string += f"({prev_char},{count}),"
            count = 1
            prev_char = data[i]

    encoded_string += f"({prev_char},{count})"
    return encoded_string


# 方法三:
def run_length_encode(data):
    count = 1  # 初始化计数器为1，因为至少有一个字符
    encoded_data = ""  # 初始化编码结果字符串

    # 遍历数据，从第二个字符开始
    for i in range(1, len(data)):
        if data[i] == data[i - 1]:  # 如果当前字符与前一个字符相同
            count += 1  # 增加计数器
        else:
            # 如果当前字符与前一个字符不同，添加前一个字符的计数和字符本身到编码结果
            encoded_data += "(" + data[i - 1] + "," + str(count) + "),"
            count = 1  # 重置计数器为1，因为遇到了新的字符

    # 处理最后一个字符，因为循环在最后一个字符前结束
    encoded_data += "(" + str(count) + "," + data[-1] + ")"

    return encoded_data  # 返回编码结果字符串

解码

def run_length_decode(encoded_data):
    """
    解码Run-Length Encoding (RLE)的数据。

    :param encoded_data: RLE编码的字符串
    :return: 解码后的原始数据
    """
    decoded_data = ""  # 初始化解码后的数据字符串
    i = 0  # 初始化索引变量

    # 遍历编码字符串
    while i < len(encoded_data):
        # 跳过左括号
        if encoded_data[i] == "(":
            i += 1
        else:
            # 解析字符
            char = ""
            while encoded_data[i] != ",":
                char += encoded_data[i]
                i += 1
            i += 1  # 跳过逗号

            # 解析计数
            count = 0
            while encoded_data[i] != ")":
                count = count * 10 + int(encoded_data[i])
                i += 1
            i += 2  # 跳过右括号

            # 将字符重复计数次添加到解码数据中
            decoded_data += char * count

    return decoded_data  # 返回解码后的数据

这个解码函数的工作原理如下：

1. 初始化一个空字符串decoded_data来存储解码后的数据。
2. 使用一个索引变量i来遍历编码字符串encoded_data。
3. 当遇到左括号时，跳过它，因为左括号只是编码的一部分，不包含实际数据。
4. 解析字符部分，直到遇到逗号。这个字符是被编码的字符。
5. 解析计数部分，直到遇到右括号。这个数字表示字符应该重复的次数。
6. 将字符重复计数次添加到decoded_data中。
7. 重复上述步骤，直到遍历完整个编码字符串。
8. 返回解码后的数据decoded_data。
   这个函数假设输入的编码字符串是有效的，并且编码格式是正确的。在实际应用中，可能需要添加额外的错误检查和处理逻辑来确保函数的鲁棒性。

测试数据

if __name__ == "__main__":
    # 测试游程编码
    test_string = "AAABBBCCDAA"
    print("test_string: ", test_string)
    encoded_test_string = run_length_encode(test_string)
    print("encoded_test_string: ", encoded_test_string)
    decoded_test_string = run_length_decode(encoded_test_string)
    print("decoded_test_string: ", decoded_test_string)

输出如下：

test_string:  AAABBBCCDAA
encoded_test_string:  (A,3),(B,3),(C,2),(D,1),(A,2)
decoded_test_string:  AAABBBCCDAA