C# 霍夫曼二叉树压缩算法实现

知道有的人比较懒,直接贴全部代码.
一开始一次性Code完了压缩部分代码.只调试了2,3次就成功了.
一次性写150行代码,没遇到什么bug的感觉还是蛮爽的.
写解压代码,才发现压缩代码有些细节问题.
对最后一个字符处理问题.
遇到比较折腾点:构建二叉树时,把原本应该是(叶结点的有值的)节点放在了左节点,正确应该放在右节点,导致生成的编码序列不满足(任意编码不是其他编码的前缀).导致解码失败.
使用方法:

  var srcData = Encoding.UTF8.GetBytes(textBox1.Text);
            var cpsData = Compress(srcData);
            treeView1.ExpandAll();
           var depData = DeCompress(cpsData);
            var depStr = Encoding.UTF8.GetString(depData );

这个TreeView就是显示二叉树的,要添加控件,或者删除代码.

快速理解:
1.此压缩直接对字节流进行压缩.
2.压缩原理:字节流对每个直接使用率不平均,所以用变长的编码对256个字节重新编码,以较短的编码表示使用率高的字节,较长编码表示使用率低的字节.
所以总体来看,用新的编码表示的字节流要比原来的短.(除非字节流特别小,压缩效果就不好)
3.由于二叉树的性质,将使用率低的先加入树,使用率高的后加入作为使用率低的节点的父节点的兄弟节点(因为有值的节点必须是叶结点).从最底下向上构建
二叉树.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;

namespace 霍夫曼二叉树压缩
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            var s=GetCode(25);
           var b= GetByteByCode(s);
        }

        private void button1_Click(object sender, EventArgs e)
        {
            var srcData = Encoding.UTF8.GetBytes(textBox1.Text);
            var cpsData = Compress(srcData);
            treeView1.ExpandAll();
           var depData = DeCompress(cpsData);
            var depStr = Encoding.UTF8.GetString(depData );
        }
        
        Dictionary<int, string> dicCode = new Dictionary<int, string>();
        byte[] Compress(byte[] data)
        {
            Dictionary<byte, int> everyCount = new Dictionary<byte, int>();
            foreach (var d in data)
            {
                if(everyCount.ContainsKey(d)==false )
                    everyCount.Add(d,0);
                everyCount[d]++;
            }
            var orderAscCounts = everyCount.OrderBy(a=>a.Value);
            Queue<Count> queCouts = new Queue<Count>();
            orderAscCounts.ToList().ForEach(d => {
                queCouts.Enqueue(new Count { key=d.Key, count=d.Value });
            });
            BuildTree(ref queCouts);
            foreach (var a in BNode.nodes)
            {
                var code = new string(GetCode(a).Reverse().ToArray());
                dicCode.Add(a.key,code);
            }
            BNode root = BNode.nodes[0];
            while(root.parent!=null){
                root = root.parent;
            }
            CreateTreeView(root,treeView1.Nodes);
            string curCode = "";
            List<byte> outData = new List<byte>();
            foreach (var d in data)
            {
                curCode += dicCode[d];
                if (curCode.Length >= 8)
                {
                    byte curBit = GetByteByCode(curCode.Substring(0,8));
                    outData.Add(curBit);
                    curCode = curCode.Length > 8 ? curCode.Substring(8, curCode.Length - 8) : "";
                }
            }
            if (curCode != "")
            {
                curCode = curCode.PadRight(8,'0');
                byte curBit = GetByteByCode(curCode);
                outData.Add(curBit);
            }
         
            return outData.ToArray();
        }

        byte[] DeCompress(byte[] data)
        {
            string codes = "";
            for (int i = 0; i < data.Length - 1;i++ )
            {
                codes += GetCode(data[i]);
            }
            codes += GetCode(data[data.Length-1]).TrimEnd('0');
            var bdata = GetCode(codes);

            return bdata;
        }

        byte GetByteByCode(string curCode)
        {
            return Convert.ToByte(curCode, 2);
        }
        byte[] GetCode(string code)
        {
            List<byte> datas = new List<byte>();
            int pos = 0;
            var orderDicCode=dicCode.OrderByDescending(a=>a.Value.Length);
            do{
                int p=-1;
                foreach (var vCode in orderDicCode)
                {
                     p = code.IndexOf(vCode.Value);
                    if (p == 0)
                    {
                        datas.Add((byte)vCode.Key);
                        code = code.Substring(vCode.Value.Length , code.Length-vCode.Value.Length );
                        break;
                    }
                }
                if (p == -1)
                {
                    throw new Exception("解压出错:发现未能识别的编码,编码表或数据已被破坏!");
                }
            }while(code.Length>0);

           /* for (int i = 1; pos + i < code.Length ; i++)
            {
                var firstCode = code.Substring(pos, i);
                var secondCode = code.Substring(pos, i + 1);

                var first = dicCode.Where(a => a.Value == firstCode);
                var second = dicCode.Where(a => a.Value == secondCode);
                if (first.Count() > 0 && second.Count() == 0 ){
                    datas.Add( (byte)first.First().Key);
                    pos = pos+i;
                    i = 1;
                }

                else if (pos + i == code.Length - 1 && second.Count() > 0)
                    datas.Add(  (byte)second.First().Key );
            }*/
            return datas.ToArray();
        }
        string GetCode(byte b )
        {
            return Convert.ToString(b, 2).PadLeft(8, '0');//Convert.ToString(b, 2) ;//: 
        }
        string GetCode(BNode a)
        {
            if (a.parent!=null)
                return (a.isLeft ? "0" : "1")+GetCode(a.parent);
            return  "" ;
        }

        BNode BuildTree(ref Queue<Count> queCouts )
        {
            var first = queCouts.Dequeue();
            var second = queCouts.Dequeue();

            var lft =first.node==null? new BNode {  key=first.key, count=first.count  } : first.node;

            var rgt = second.node == null ? new BNode { key = second.key, count = second.count } : second.node;

            if (rgt.key == -1)
            {
                var temp = lft;
                lft = rgt;
                rgt = temp;
               
            }
           
            var pnode = new BNode
            {
                key = -1, count = first.count + second.count
            };
            lft.isLeft = true;
            rgt.isLeft = false;
            pnode.left = lft;
            pnode.right = rgt;
            lft.parent = pnode;
            
            rgt.parent = pnode;
            if (lft.key != -1)
                BNode.nodes.Add(lft);
            if (rgt.key != -1)
                BNode.nodes.Add(rgt);
            if (queCouts.Count > 0){
                 queCouts.Enqueue(new Count { count=pnode.count, key=pnode.key, node=pnode });
                var orderQue = queCouts.OrderBy(q => q.count).ToList();
                queCouts.Clear();
                foreach (var a in orderQue)
                    queCouts.Enqueue(a);
                return BuildTree(ref queCouts);
            }
            else
                return pnode;
        }

        void CreateTreeView(BNode node , TreeNodeCollection tnc)
        {
            if (node == null) return;
            var newNode = tnc.Add((node.isLeft ? "0" : "1") + (node.key!=-1?"-"+node.key + ":" + node.count:""));
            CreateTreeView(node.left,newNode.Nodes);
            CreateTreeView(node.right, newNode.Nodes);
        }

        class Count
        {
           public int key;
           public int count;
           public BNode node;
        }

        class BNode{
            public int key;
            public int count;
            public BNode left;
            public BNode right;
            public BNode parent;
            public bool isLeft = false;
            public static List<BNode> nodes = new List< BNode>();

        }
    }
}