Bagaimana untuk melaksanakan algoritma pemampatan LZW dalam C#

Cara melaksanakan algoritma pemampatan LZW dalam C#

Pengenalan:
Dengan pertumbuhan data yang berterusan, penyimpanan dan penghantaran data telah menjadi tugas penting. Algoritma pemampatan LZW (Lempel-Ziv-Welch) ialah algoritma pemampatan tanpa kehilangan yang biasa digunakan yang boleh mengurangkan saiz data dengan berkesan. Artikel ini akan memperkenalkan cara untuk melaksanakan algoritma pemampatan LZW dalam C# dan memberikan contoh kod khusus.

1. Prinsip algoritma pemampatan LZW
   Algoritma pemampatan LZW ialah algoritma pemampatan kamus Prinsip asasnya ialah untuk memetakan jujukan aksara berterusan yang muncul dalam aliran data input ke dalam pengekodan unik. Apabila memampatkan, urutan aksara ditambah secara beransur-ansur pada kamus dan pengekodan yang sepadan adalah output apabila nyahmampat, urutan aksara yang sepadan dalam kamus ditemui melalui pengekodan dan output. Teras algoritma adalah untuk mengemas kini kamus secara berterusan supaya ia boleh sepadan dengan aliran data input.
2. Langkah pelaksanaan algoritma pemampatan LZW
   (1) Mulakan kamus: Mulakan setiap aksara dalam aliran data input kepada pengekodan bebas.
   (2) Baca aksara pertama dalam aliran data input sebagai aksara semasa.
   (3) Ulangi langkah berikut sehingga tamat aliran data:
   a. Baca aksara seterusnya dan sambung aksara semasa dan aksara seterusnya ke dalam urutan aksara baharu.
   b. Jika urutan aksara sudah wujud dalam kamus, kemas kini aksara semasa kepada urutan aksara baharu dan teruskan membaca aksara seterusnya.
   c. Jika urutan aksara tidak wujud dalam kamus, keluarkan aksara semasa, tambahkan urutan aksara baharu pada kamus dan kemas kini aksara semasa kepada aksara seterusnya.
   (4) Keluarkan baki aksara semasa.
3. Contoh Kod C#
   Berikut ialah contoh kod untuk melaksanakan algoritma pemampatan LZW dalam C#:

using System;
using System.Collections.Generic;
using System.Text;

class LZWCompression
{
    public static List<int> Compress(string data)
    {
        Dictionary<string, int> dictionary = new Dictionary<string, int>();
        List<int> compressedData = new List<int>();

        int currentCode = 256;

        for (int i = 0; i < 256; i++)
        {
            dictionary.Add(((char)i).ToString(), i);
        }

        string currentString = "";

        foreach (char c in data)
        {
            string newString = currentString + c;

            if (dictionary.ContainsKey(newString))
            {
                currentString = newString;
            }
            else
            {
                compressedData.Add(dictionary[currentString]);
                dictionary.Add(newString, currentCode);
                currentCode++;
                currentString = c.ToString();
            }
        }

        if (currentString != "")
        {
            compressedData.Add(dictionary[currentString]);
        }

        return compressedData;
    }

    public static string Decompress(List<int> compressedData)
    {
        Dictionary<int, string> dictionary = new Dictionary<int, string>();
        StringBuilder decompressedData = new StringBuilder();

        int currentCode = 256;

        for (int i = 0; i < 256; i++)
        {
            dictionary.Add(i, ((char)i).ToString());
        }

        int previousCode = compressedData[0].Value.ToString();

        decompressedData.Append(dictionary[previousCode]);

        for (int i = 1; i < compressedData.Count; i++)
        {
            int currentCode = compressedData[i];

            if (dictionary.ContainsKey(currentCode))
            {
                decompressedData.Append(dictionary[currentCode]);
                string newEntry = dictionary[previousCode] + dictionary[currentCode][0];
                dictionary.Add(currentCode, newEntry);
                previousCode = currentCode;
            }
            else
            {
                string newEntry = dictionary[previousCode] + dictionary[previousCode][0];
                decompressedData.Append(newEntry);
                dictionary.Add(currentCode, newEntry);
                previousCode = currentCode;
            }
        }

        return decompressedData.ToString();
    }
}

Berikut ialah contoh penggunaan algoritma pemampatan LZW:

using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        string originalData = "AAAAABBBBCCCCCDDDDDEE";
        
        Console.WriteLine("原始数据： " + originalData);
        
        List<int> compressedData = LZWCompression.Compress(originalData);
        
        Console.WriteLine("压缩后的数据： " + string.Join(",", compressedData));

        string decompressedData = LZWCompression.Decompress(compressedData);

        Console.WriteLine("解压缩后的数据： " + decompressedData);

        Console.ReadLine();
    }
}

Dalam contoh kod di atas, kami menggunakan kaedah LZWCompression类进行了数据的压缩与解压缩，其中压缩使用了Compress方法，解压缩使用了Decompress.

Kesimpulan:
Artikel ini memperkenalkan cara melaksanakan algoritma pemampatan LZW dalam C# dan memberikan contoh kod khusus. Algoritma pemampatan LZW ialah algoritma pemampatan tanpa kehilangan yang biasa digunakan dan berkesan yang boleh membantu kami mengurangkan saiz data dan meningkatkan kecekapan penyimpanan dan penghantaran data.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan algoritma pemampatan LZW dalam C#. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!