• C#，哈夫曼编码（Huffman Code）压缩（Compress ）与解压缩（Decompress）算法与源代码

     David A. Huffman

    1 哈夫曼编码简史（Huffman code）

    1951年，哈夫曼和他在MIT信息论的同学需要选择是完成学期报告还是期末考试。导师Robert M. Fano给他们的学期报告的题目是，寻找最有效的二进制编码。由于无法证明哪个已有编码是最有效的，哈夫曼放弃对已有编码的研究，转向新的探索，最终发现了基于有序频率二叉树编码的想法，并很快证明了这个方法是最有效的。由于这个算法，学生终于青出于蓝，超过了他那曾经和信息论创立者香农共同研究过类似编码的导师。哈夫曼使用自底向上的方法构建二叉树，避免了次优算法Shannon-Fano编码的最大弊端──自顶向下构建树。
    1952年，David A. Huffman在麻省理工攻读博士时发表了《一种构建极小多余编码的方法》，一文，它一般就叫做Huffman编码。A Method for the Construction of Minimum-Redundancy Codesicon-default.png?t=N7T8https://www.ias.ac.in/article/fulltext/reso/011/02/0091-0099
    Huffman在1952年根据香农（Shannon）在1948年和范若（Fano）在1949年阐述的这种编码思想提出了一种不定长编码的方法，也称霍夫曼（Huffman）编码。霍夫曼编码的基本方法是先对图像数据扫描一遍，计算出各种像素出现的概率，按概率的大小指定不同长度的唯一码字，由此得到一张该图像的霍夫曼码表。编码后的图像数据记录的是每个像素的码字，而码字与实际像素值的对应关系记录在码表中。

    2 赫夫曼编码

    赫夫曼编码是可变字长编码(VLC)的一种。 Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长 度最短的码字，有时称之为最佳编码，一般就称Huffman编码。下面引证一个定理，该定理保证了按字符出现概率分配码长，可使平均码长最短。

    3 源程序

    using System;
    using System.IO;
    using System.Text;
    using System.Linq;
    using System.Collections;
    using System.Collections.Generic;

    namespace Legalsoft.Truffer.Algorithm
    {
        ///


        /// 哈夫曼编码的压缩与解压缩
        ///
        public class HuffmanCompressor
        {
            private HuffmanNode oRootHuffmanNode { get; set; } = null;
            private List oValueHuffmanNodes { get; set; } = null;

            private List BuildBinaryTree(string Value)
            {
                List oHuffmanNodes = GetInitialNodeList();

                Value.ToList().ForEach(m => oHuffmanNodes[m].Weight++);

                oHuffmanNodes = oHuffmanNodes
                    .Where(m => (m.Weight > 0))
                    .OrderBy(m => (m.Weight))
                    .ThenBy(m => (m.Value))
                    .ToList();

                oHuffmanNodes = UpdateNodeParents(oHuffmanNodes);

                oRootHuffmanNode = oHuffmanNodes[0];
                oHuffmanNodes.Clear();

                SortNodes(oRootHuffmanNode, oHuffmanNodes);

                return oHuffmanNodes;
            }

            public void Compress(string FileName)
            {
                FileInfo oFileInfo = new FileInfo(FileName);

                if (oFileInfo.Exists == true)
                {
                    string sFileContents = "";

                    using (StreamReader oStreamReader = new StreamReader(File.OpenRead(FileName)))
                    {
                        sFileContents = oStreamReader.ReadToEnd();
                    }

                    List oHuffmanNodes = BuildBinaryTree(sFileContents);

                    oValueHuffmanNodes = oHuffmanNodes
                        .Where(m => (m.Value.HasValue == true))
                        .OrderBy(m => (m.BinaryWord))
                        .ToList();

                    Dictionary oCharToBinaryWordDictionary = new Dictionary();
                    foreach (HuffmanNode oHuffmanNode in oValueHuffmanNodes)
                    {
                        oCharToBinaryWordDictionary.Add(oHuffmanNode.Value.Value, oHuffmanNode.BinaryWord);
                    }

                    StringBuilder oStringBuilder = new StringBuilder();
                    List oByteList = new List();
                    for (int i = 0; i < sFileContents.Length; i++)
                    {
                        string sWord = "";

                        oStringBuilder.Append(oCharToBinaryWordDictionary[sFileContents[i]]);

                        while (oStringBuilder.Length >= 8)
                        {
                            sWord = oStringBuilder.ToString().Substring(0, 8);

                            oStringBuilder.Remove(0, sWord.Length);
                        }

                        if (String.IsNullOrEmpty(sWord) == false)
                        {
                            oByteList.Add(Convert.ToByte(sWord, 2));
                        }
                    }

                    if (oStringBuilder.Length > 0)
                    {
                        string sWord = oStringBuilder.ToString();

                        if (String.IsNullOrEmpty(sWord) == false)
                        {
                            oByteList.Add(Convert.ToByte(sWord, 2));
                        }
                    }

                    string sCompressedFileName = Path.Combine(oFileInfo.Directory.FullName, String.Format("{0}.compressed", oFileInfo.Name.Replace(oFileInfo.Extension, "")));
                    if (File.Exists(sCompressedFileName) == true)
                    {
                        File.Delete(sCompressedFileName);
                    }

                    using (FileStream oFileStream = File.OpenWrite(sCompressedFileName))
                    {
                        oFileStream.Write(oByteList.ToArray(), 0, oByteList.Count);
                    }
                }
            }

            public void Decompress(string FileName)
            {
                FileInfo oFileInfo = new FileInfo(FileName);

                if (oFileInfo.Exists == true)
                {
                    string sCompressedFileName = String.Format("{0}.compressed", oFileInfo.FullName.Replace(oFileInfo.Extension, ""));

                    byte[] oBuffer = null;
                    using (FileStream oFileStream = File.OpenRead(sCompressedFileName))
                    {
                        oBuffer = new byte[oFileStream.Length];
                        oFileStream.Read(oBuffer, 0, oBuffer.Length);
                    }

                    HuffmanNode oZeroHuffmanNode = oRootHuffmanNode;
                    while (oZeroHuffmanNode.Left != null)
                    {
                        oZeroHuffmanNode = oZeroHuffmanNode.Left;
                    }

                    HuffmanNode oCurrentHuffmanNode = null;
                    StringBuilder oStringBuilder = new StringBuilder();

                    for (int i = 0; i < oBuffer.Length; i++)
                    {
                        string sBinaryWord = "";
                        byte oByte = oBuffer[i];

                        if (oByte == 0)
                        {
                            sBinaryWord = oZeroHuffmanNode.BinaryWord;
                        }
                        else
                        {
                            sBinaryWord = Convert.ToString(oByte, 2);
                        }

                        if ((sBinaryWord.Length < 8) && (i < (oBuffer.Length - 1)))
                        {
                            StringBuilder oBinaryStringBuilder = new StringBuilder(sBinaryWord);
                            while (oBinaryStringBuilder.Length < 8)
                            {
                                oBinaryStringBuilder.Insert(0, "0");
                            }

                            sBinaryWord = oBinaryStringBuilder.ToString();
                        }

                        for (int j = 0; j < sBinaryWord.Length; j++)
                        {
                            char cValue = sBinaryWord[j];

                            if (oCurrentHuffmanNode == null)
                            {
                                oCurrentHuffmanNode = oRootHuffmanNode;
                            }

                            if (cValue == '0')
                            {
                                oCurrentHuffmanNode = oCurrentHuffmanNode.Left;
                            }
                            else
                            {
                                oCurrentHuffmanNode = oCurrentHuffmanNode.Right;
                            }

                            if ((oCurrentHuffmanNode.Left == null) && (oCurrentHuffmanNode.Right == null))
                            {
                                oStringBuilder.Append(oCurrentHuffmanNode.Value.Value);
                                oCurrentHuffmanNode = null;
                            }
                        }
                    }

                    string sUncompressedFileName = Path.Combine(oFileInfo.Directory.FullName, String.Format("{0}.uncompressed", oFileInfo.Name.Replace(oFileInfo.Extension, "")));

                    if (File.Exists(sUncompressedFileName) == true)
                    {
                        File.Delete(sUncompressedFileName);
                    }

                    using (StreamWriter oStreamWriter = new StreamWriter(File.OpenWrite(sUncompressedFileName)))
                    {
                        oStreamWriter.Write(oStringBuilder.ToString());
                    }
                }
            }

            private static List GetInitialNodeList()
            {
                List oGetInitialNodeList = new List();

                for (int i = Char.MinValue; i < Char.MaxValue; i++)
                {
                    oGetInitialNodeList.Add(new HuffmanNode((char)(i)));
                }

                return oGetInitialNodeList;
            }

            private static void SortNodes(HuffmanNode Node, List Nodes)
            {
                if (Nodes.Contains(Node) == false)
                {
                    Nodes.Add(Node);
                }

                if (Node.Left != null)
                {
                    SortNodes(Node.Left, Nodes);
                }

                if (Node.Right != null)
                {
                    SortNodes(Node.Right, Nodes);
                }
            }

            private static List UpdateNodeParents(List Nodes)
            {
                while (Nodes.Count > 1)
                {
                    int iOperations = (Nodes.Count / 2);
                    for (int iOperation = 0, i = 0, j = 1; iOperation < iOperations; iOperation++, i += 2, j += 2)
                    {
                        if (j < Nodes.Count)
                        {
                            HuffmanNode oParentHuffmanNode = new HuffmanNode(Nodes[i], Nodes[j]);
                            Nodes.Add(oParentHuffmanNode);

                            Nodes[i] = null;
                            Nodes[j] = null;
                        }
                    }

                    Nodes = Nodes
                        .Where(m => (m != null))
                        .OrderBy(m => (m.Weight))
                        .ToList();
                }

                return Nodes;
            }
        }

        public class HuffmanNode
        {
            private string sBinaryWord { get; set; } = "";
            private bool bIsLeftNode { get; set; } = false;
            private bool bIsRightNode { get; set; } = false;
            private HuffmanNode oLeft { get; set; } = null;
            private HuffmanNode oParent { get; set; } = null;
            private HuffmanNode oRight { get; set; } = null;
            private char? cValue { get; set; } = ' ';
            private int iWeight { get; set; } = 0;

            public HuffmanNode()
            {
            }

            public HuffmanNode(char Value)
            {
                cValue = Value;
            }

            public HuffmanNode(HuffmanNode Left, HuffmanNode Right)
            {
                oLeft = Left;
                oLeft.oParent = this;
                oLeft.bIsLeftNode = true;

                oRight = Right;
                oRight.oParent = this;
                oRight.bIsRightNode = true;

                iWeight = (oLeft.Weight + oRight.Weight);
            }

            public string BinaryWord
            {
                get
                {
                    string sReturnValue = "";

                    if (String.IsNullOrEmpty(sBinaryWord) == true)
                    {
                        StringBuilder oStringBuilder = new StringBuilder();

                        HuffmanNode oHuffmanNode = this;

                        while (oHuffmanNode != null)
                        {
                            if (oHuffmanNode.bIsLeftNode == true)
                            {
                                oStringBuilder.Insert(0, "0");
                            }

                            if (oHuffmanNode.bIsRightNode == true)
                            {
                                oStringBuilder.Insert(0, "1");
                            }

                            oHuffmanNode = oHuffmanNode.oParent;
                        }

                        sReturnValue = oStringBuilder.ToString();
                        sBinaryWord = sReturnValue;
                    }
                    else
                    {
                        sReturnValue = sBinaryWord;
                    }

                    return sReturnValue;
                }
            }

            public HuffmanNode Left
            {
                get
                {
                    return oLeft;
                }
            }

            public HuffmanNode Parent
            {
                get
                {
                    return oParent;
                }
            }

            public HuffmanNode Right
            {
                get
                {
                    return oRight;
                }
            }

            public char? Value
            {
                get
                {
                    return cValue;
                }
            }

            public int Weight
            {
                get
                {
                    return iWeight;
                }
                set
                {
                    iWeight = value;
                }
            }

            public static int BinaryStringToInt32(string Value)
            {
                int iBinaryStringToInt32 = 0;

                for (int i = (Value.Length - 1), j = 0; i >= 0; i--, j++)
                {
                    iBinaryStringToInt32 += ((Value[j] == '0' ? 0 : 1) * (int)(Math.Pow(2, i)));
                }

                return iBinaryStringToInt32;
            }

            public override string ToString()
            {
                StringBuilder sb = new StringBuilder();

                if (cValue.HasValue == true)
                {
                    sb.AppendFormat("'{0}' ({1}) - {2} ({3})", cValue.Value, iWeight, BinaryWord, BinaryStringToInt32(BinaryWord));
                }
                else
                {
                    if ((oLeft != null) && (oRight != null))
                    {
                        if ((oLeft.Value.HasValue == true) && (oRight.Value.HasValue == true))
                        {
                            sb.AppendFormat("{0} + {1} ({2})", oLeft.Value, oRight.Value, iWeight);
                        }
                        else
                        {
                            sb.AppendFormat("{0}, {1} - ({2})", oLeft, oRight, iWeight);
                        }
                    }
                    else
                    {
                        sb.Append(iWeight);
                    }
                }

                return sb.ToString();
            }
        }
    }
     

    4 源代码

    1. using System;
    2. using System.IO;
    3. using System.Text;
    4. using System.Linq;
    5. using System.Collections;
    6. using System.Collections.Generic;
    7.  
    8. namespace Legalsoft.Truffer.Algorithm
    9. {
    10.     /// 
    11.     /// 哈夫曼编码的压缩与解压缩
    12.     /// 
    13.     public class HuffmanCompressor
    14.     {
    15.         private HuffmanNode oRootHuffmanNode { get; set; } = null;
    16.         private List oValueHuffmanNodes { get; set; } = null;
    17.  
    18.         private List BuildBinaryTree(string Value)
    19.         {
    20.             List oHuffmanNodes = GetInitialNodeList();
    21.  
    22.             Value.ToList().ForEach(m => oHuffmanNodes[m].Weight++);
    23.  
    24.             oHuffmanNodes = oHuffmanNodes
    25.                 .Where(m => (m.Weight > 0))
    26.                 .OrderBy(m => (m.Weight))
    27.                 .ThenBy(m => (m.Value))
    28.                 .ToList();
    29.  
    30.             oHuffmanNodes = UpdateNodeParents(oHuffmanNodes);
    31.  
    32.             oRootHuffmanNode = oHuffmanNodes[0];
    33.             oHuffmanNodes.Clear();
    34.  
    35.             SortNodes(oRootHuffmanNode, oHuffmanNodes);
    36.  
    37.             return oHuffmanNodes;
    38.         }
    39.  
    40.         public void Compress(string FileName)
    41.         {
    42.             FileInfo oFileInfo = new FileInfo(FileName);
    43.  
    44.             if (oFileInfo.Exists == true)
    45.             {
    46.                 string sFileContents = "";
    47.  
    48.                 using (StreamReader oStreamReader = new StreamReader(File.OpenRead(FileName)))
    49.                 {
    50.                     sFileContents = oStreamReader.ReadToEnd();
    51.                 }
    52.  
    53.                 List oHuffmanNodes = BuildBinaryTree(sFileContents);
    54.  
    55.                 oValueHuffmanNodes = oHuffmanNodes
    56.                     .Where(m => (m.Value.HasValue == true))
    57.                     .OrderBy(m => (m.BinaryWord))
    58.                     .ToList();
    59.  
    60.                 Dictionary<char, string> oCharToBinaryWordDictionary = new Dictionary<char, string>();
    61.                 foreach (HuffmanNode oHuffmanNode in oValueHuffmanNodes)
    62.                 {
    63.                     oCharToBinaryWordDictionary.Add(oHuffmanNode.Value.Value, oHuffmanNode.BinaryWord);
    64.                 }
    65.  
    66.                 StringBuilder oStringBuilder = new StringBuilder();
    67.                 List<byte> oByteList = new List<byte>();
    68.                 for (int i = 0; i < sFileContents.Length; i++)
    69.                 {
    70.                     string sWord = "";
    71.  
    72.                     oStringBuilder.Append(oCharToBinaryWordDictionary[sFileContents[i]]);
    73.  
    74.                     while (oStringBuilder.Length >= 8)
    75.                     {
    76.                         sWord = oStringBuilder.ToString().Substring(0, 8);
    77.  
    78.                         oStringBuilder.Remove(0, sWord.Length);
    79.                     }
    80.  
    81.                     if (String.IsNullOrEmpty(sWord) == false)
    82.                     {
    83.                         oByteList.Add(Convert.ToByte(sWord, 2));
    84.                     }
    85.                 }
    86.  
    87.                 if (oStringBuilder.Length > 0)
    88.                 {
    89.                     string sWord = oStringBuilder.ToString();
    90.  
    91.                     if (String.IsNullOrEmpty(sWord) == false)
    92.                     {
    93.                         oByteList.Add(Convert.ToByte(sWord, 2));
    94.                     }
    95.                 }
    96.  
    97.                 string sCompressedFileName = Path.Combine(oFileInfo.Directory.FullName, String.Format("{0}.compressed", oFileInfo.Name.Replace(oFileInfo.Extension, "")));
    98.                 if (File.Exists(sCompressedFileName) == true)
    99.                 {
    100.                     File.Delete(sCompressedFileName);
    101.                 }
    102.  
    103.                 using (FileStream oFileStream = File.OpenWrite(sCompressedFileName))
    104.                 {
    105.                     oFileStream.Write(oByteList.ToArray(), 0, oByteList.Count);
    106.                 }
    107.             }
    108.         }
    109.  
    110.         public void Decompress(string FileName)
    111.         {
    112.             FileInfo oFileInfo = new FileInfo(FileName);
    113.  
    114.             if (oFileInfo.Exists == true)
    115.             {
    116.                 string sCompressedFileName = String.Format("{0}.compressed", oFileInfo.FullName.Replace(oFileInfo.Extension, ""));
    117.  
    118.                 byte[] oBuffer = null;
    119.                 using (FileStream oFileStream = File.OpenRead(sCompressedFileName))
    120.                 {
    121.                     oBuffer = new byte[oFileStream.Length];
    122.                     oFileStream.Read(oBuffer, 0, oBuffer.Length);
    123.                 }
    124.  
    125.                 HuffmanNode oZeroHuffmanNode = oRootHuffmanNode;
    126.                 while (oZeroHuffmanNode.Left != null)
    127.                 {
    128.                     oZeroHuffmanNode = oZeroHuffmanNode.Left;
    129.                 }
    130.  
    131.                 HuffmanNode oCurrentHuffmanNode = null;
    132.                 StringBuilder oStringBuilder = new StringBuilder();
    133.  
    134.                 for (int i = 0; i < oBuffer.Length; i++)
    135.                 {
    136.                     string sBinaryWord = "";
    137.                     byte oByte = oBuffer[i];
    138.  
    139.                     if (oByte == 0)
    140.                     {
    141.                         sBinaryWord = oZeroHuffmanNode.BinaryWord;
    142.                     }
    143.                     else
    144.                     {
    145.                         sBinaryWord = Convert.ToString(oByte, 2);
    146.                     }
    147.  
    148.                     if ((sBinaryWord.Length < 8) && (i < (oBuffer.Length - 1)))
    149.                     {
    150.                         StringBuilder oBinaryStringBuilder = new StringBuilder(sBinaryWord);
    151.                         while (oBinaryStringBuilder.Length < 8)
    152.                         {
    153.                             oBinaryStringBuilder.Insert(0, "0");
    154.                         }
    155.  
    156.                         sBinaryWord = oBinaryStringBuilder.ToString();
    157.                     }
    158.  
    159.                     for (int j = 0; j < sBinaryWord.Length; j++)
    160.                     {
    161.                         char cValue = sBinaryWord[j];
    162.  
    163.                         if (oCurrentHuffmanNode == null)
    164.                         {
    165.                             oCurrentHuffmanNode = oRootHuffmanNode;
    166.                         }
    167.  
    168.                         if (cValue == '0')
    169.                         {
    170.                             oCurrentHuffmanNode = oCurrentHuffmanNode.Left;
    171.                         }
    172.                         else
    173.                         {
    174.                             oCurrentHuffmanNode = oCurrentHuffmanNode.Right;
    175.                         }
    176.  
    177.                         if ((oCurrentHuffmanNode.Left == null) && (oCurrentHuffmanNode.Right == null))
    178.                         {
    179.                             oStringBuilder.Append(oCurrentHuffmanNode.Value.Value);
    180.                             oCurrentHuffmanNode = null;
    181.                         }
    182.                     }
    183.                 }
    184.  
    185.                 string sUncompressedFileName = Path.Combine(oFileInfo.Directory.FullName, String.Format("{0}.uncompressed", oFileInfo.Name.Replace(oFileInfo.Extension, "")));
    186.  
    187.                 if (File.Exists(sUncompressedFileName) == true)
    188.                 {
    189.                     File.Delete(sUncompressedFileName);
    190.                 }
    191.  
    192.                 using (StreamWriter oStreamWriter = new StreamWriter(File.OpenWrite(sUncompressedFileName)))
    193.                 {
    194.                     oStreamWriter.Write(oStringBuilder.ToString());
    195.                 }
    196.             }
    197.         }
    198.  
    199.         private static List GetInitialNodeList()
    200.         {
    201.             List oGetInitialNodeList = new List();
    202.  
    203.             for (int i = Char.MinValue; i < Char.MaxValue; i++)
    204.             {
    205.                 oGetInitialNodeList.Add(new HuffmanNode((char)(i)));
    206.             }
    207.  
    208.             return oGetInitialNodeList;
    209.         }
    210.  
    211.         private static void SortNodes(HuffmanNode Node, List Nodes)
    212.         {
    213.             if (Nodes.Contains(Node) == false)
    214.             {
    215.                 Nodes.Add(Node);
    216.             }
    217.  
    218.             if (Node.Left != null)
    219.             {
    220.                 SortNodes(Node.Left, Nodes);
    221.             }
    222.  
    223.             if (Node.Right != null)
    224.             {
    225.                 SortNodes(Node.Right, Nodes);
    226.             }
    227.         }
    228.  
    229.         private static List UpdateNodeParents(List Nodes)
    230.         {
    231.             while (Nodes.Count > 1)
    232.             {
    233.                 int iOperations = (Nodes.Count / 2);
    234.                 for (int iOperation = 0, i = 0, j = 1; iOperation < iOperations; iOperation++, i += 2, j += 2)
    235.                 {
    236.                     if (j < Nodes.Count)
    237.                     {
    238.                         HuffmanNode oParentHuffmanNode = new HuffmanNode(Nodes[i], Nodes[j]);
    239.                         Nodes.Add(oParentHuffmanNode);
    240.  
    241.                         Nodes[i] = null;
    242.                         Nodes[j] = null;
    243.                     }
    244.                 }
    245.  
    246.                 Nodes = Nodes
    247.                     .Where(m => (m != null))
    248.                     .OrderBy(m => (m.Weight))
    249.                     .ToList();
    250.             }
    251.  
    252.             return Nodes;
    253.         }
    254.     }
    255.  
    256.     public class HuffmanNode
    257.     {
    258.         private string sBinaryWord { get; set; } = "";
    259.         private bool bIsLeftNode { get; set; } = false;
    260.         private bool bIsRightNode { get; set; } = false;
    261.         private HuffmanNode oLeft { get; set; } = null;
    262.         private HuffmanNode oParent { get; set; } = null;
    263.         private HuffmanNode oRight { get; set; } = null;
    264.         private char? cValue { get; set; } = ' ';
    265.         private int iWeight { get; set; } = 0;
    266.  
    267.         public HuffmanNode()
    268.         {
    269.         }
    270.  
    271.         public HuffmanNode(char Value)
    272.         {
    273.             cValue = Value;
    274.         }
    275.  
    276.         public HuffmanNode(HuffmanNode Left, HuffmanNode Right)
    277.         {
    278.             oLeft = Left;
    279.             oLeft.oParent = this;
    280.             oLeft.bIsLeftNode = true;
    281.  
    282.             oRight = Right;
    283.             oRight.oParent = this;
    284.             oRight.bIsRightNode = true;
    285.  
    286.             iWeight = (oLeft.Weight + oRight.Weight);
    287.         }
    288.  
    289.         public string BinaryWord
    290.         {
    291.             get
    292.             {
    293.                 string sReturnValue = "";
    294.  
    295.                 if (String.IsNullOrEmpty(sBinaryWord) == true)
    296.                 {
    297.                     StringBuilder oStringBuilder = new StringBuilder();
    298.  
    299.                     HuffmanNode oHuffmanNode = this;
    300.  
    301.                     while (oHuffmanNode != null)
    302.                     {
    303.                         if (oHuffmanNode.bIsLeftNode == true)
    304.                         {
    305.                             oStringBuilder.Insert(0, "0");
    306.                         }
    307.  
    308.                         if (oHuffmanNode.bIsRightNode == true)
    309.                         {
    310.                             oStringBuilder.Insert(0, "1");
    311.                         }
    312.  
    313.                         oHuffmanNode = oHuffmanNode.oParent;
    314.                     }
    315.  
    316.                     sReturnValue = oStringBuilder.ToString();
    317.                     sBinaryWord = sReturnValue;
    318.                 }
    319.                 else
    320.                 {
    321.                     sReturnValue = sBinaryWord;
    322.                 }
    323.  
    324.                 return sReturnValue;
    325.             }
    326.         }
    327.  
    328.         public HuffmanNode Left
    329.         {
    330.             get
    331.             {
    332.                 return oLeft;
    333.             }
    334.         }
    335.  
    336.         public HuffmanNode Parent
    337.         {
    338.             get
    339.             {
    340.                 return oParent;
    341.             }
    342.         }
    343.  
    344.         public HuffmanNode Right
    345.         {
    346.             get
    347.             {
    348.                 return oRight;
    349.             }
    350.         }
    351.  
    352.         public char? Value
    353.         {
    354.             get
    355.             {
    356.                 return cValue;
    357.             }
    358.         }
    359.  
    360.         public int Weight
    361.         {
    362.             get
    363.             {
    364.                 return iWeight;
    365.             }
    366.             set
    367.             {
    368.                 iWeight = value;
    369.             }
    370.         }
    371.  
    372.         public static int BinaryStringToInt32(string Value)
    373.         {
    374.             int iBinaryStringToInt32 = 0;
    375.  
    376.             for (int i = (Value.Length - 1), j = 0; i >= 0; i--, j++)
    377.             {
    378.                 iBinaryStringToInt32 += ((Value[j] == '0' ? 0 : 1) * (int)(Math.Pow(2, i)));
    379.             }
    380.  
    381.             return iBinaryStringToInt32;
    382.         }
    383.  
    384.         public override string ToString()
    385.         {
    386.             StringBuilder sb = new StringBuilder();
    387.  
    388.             if (cValue.HasValue == true)
    389.             {
    390.                 sb.AppendFormat("'{0}' ({1}) - {2} ({3})", cValue.Value, iWeight, BinaryWord, BinaryStringToInt32(BinaryWord));
    391.             }
    392.             else
    393.             {
    394.                 if ((oLeft != null) && (oRight != null))
    395.                 {
    396.                     if ((oLeft.Value.HasValue == true) && (oRight.Value.HasValue == true))
    397.                     {
    398.                         sb.AppendFormat("{0} + {1} ({2})", oLeft.Value, oRight.Value, iWeight);
    399.                     }
    400.                     else
    401.                     {
    402.                         sb.AppendFormat("{0}, {1} - ({2})", oLeft, oRight, iWeight);
    403.                     }
    404.                 }
    405.                 else
    406.                 {
    407.                     sb.Append(iWeight);
    408.                 }
    409.             }
    410.  
    411.             return sb.ToString();
    412.         }
    413.     }
    414. }

  • 相关阅读:
    如何提高爬虫效率
    极简idea下git操作（二）
    Scrapy 2.6.2 代理设置，Proxy-Authorization 安全漏洞修复
    Linux mmap 的作用是什么？
    【金融投资】一文带你了解 加息、降息与利率
    JAVA 开发中常用的工具有哪些？
    Oracle主备切换，ogg恢复方法(集成模式)
    c语言数据结构，你可能还不知道的顺序表
    VuePress@next 使用数学公式插件
    SpringBoot课堂笔记20230913
  • 原文地址：https://blog.csdn.net/beijinghorn/article/details/124789465