欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

算法系列15天速成——第十三天 树操作【下】

程序员文章站 2024-01-23 19:00:10
听说赫夫曼胜过了他的导师,被认为”青出于蓝而胜于蓝“,这句话也是我比较欣赏的,嘻嘻。 一  概念     了解”赫夫曼树“之前,...

听说赫夫曼胜过了他的导师,被认为”青出于蓝而胜于蓝“,这句话也是我比较欣赏的,嘻嘻。

一  概念

    了解”赫夫曼树“之前,几个必须要知道的专业名词可要熟练记住啊。

    1: 结点的权

            “权”就相当于“重要度”,我们形象的用一个具体的数字来表示,然后通过数字的大小来决定谁重要,谁不重要。

    2: 路径

             树中从“一个结点"到“另一个结点“之间的分支。

    3: 路径长度

             一个路径上的分支数量。

    4: 树的路径长度

             从树的根节点到每个节点的路径长度之和。

    5: 节点的带权路径路劲长度

             其实也就是该节点到根结点的路径长度*该节点的权。

    6:   树的带权路径长度

             树中各个叶节点的路径长度*该叶节点的权的和,常用wpl(weight path length)表示。

二: 构建赫夫曼树

        上面说了那么多,肯定是为下面做铺垫,这里说赫夫曼树,肯定是要说赫夫曼树咋好咋好,赫夫曼树是一种最优二叉树,

         因为他的wpl是最短的,何以见得?我们可以上图说话。

算法系列15天速成——第十三天 树操作【下】

现在我们做一个wpl的对比:

图a: wpl= 5*2 + 7*2 +2*2+13*2=54

图b:wpl=5*3+2*3+7*2+13*1=48

 

我们对比一下,图b的wpl最短的,地球人已不能阻止wpl还能比“图b”的小,所以,“图b"就是一颗赫夫曼树,那么大家肯定

要问,如何构建一颗赫夫曼树,还是上图说话。

算法系列15天速成——第十三天 树操作【下】

 

第一步: 我们将所有的节点都作为独根结点。

第二步:   我们将最小的c和a组建为一个新的二叉树,权值为左右结点之和。

第三步: 将上一步组建的新节点加入到剩下的节点中,排除上一步组建过的左右子树,我们选中b组建新的二叉树,然后取权值。

第四步: 同上。

 

三: 赫夫曼编码

      大家都知道,字符,汉字,数字在计算机中都是以0,1来表示的,相应的存储都是有一套编码方案来支撑的,比如asc码。

 这样才能在"编码“和”解码“的过程中不会成为乱码,但是asc码不理想的地方就是等长的,其实我们都想用较少的空间来存储

更多的东西,那么我们就要采用”不等长”的编码方案来存储,那么“何为不等长呢“?其实也就是出现次数比较多的字符我们采用短编码,

出现次数较少的字符我们采用长编码,恰好,“赫夫曼编码“就是不等长的编码。

    这里大家只要掌握赫夫曼树的编码规则:左子树为0,右子树为1,对应的编码后的规则是:从根节点到子节点

a: 111

b: 10

c: 110

d: 0

算法系列15天速成——第十三天 树操作【下】

 

四: 实现

      不知道大家懂了没有,不懂的话多看几篇,下面说下赫夫曼的具体实现。

         第一步:构建赫夫曼树。

         第二步:对赫夫曼树进行编码。

         第三步:压缩操作。

         第四步:解压操作。

 

1:首先看下赫夫曼树的结构,这里字段的含义就不解释了。

复制代码 代码如下:

#region 赫夫曼树结构
    /// <summary>
/// 赫夫曼树结构
/// </summary>
    public class huffmantree
    {
        public int weight { get; set; }

        public int parent { get; set; }

        public int left { get; set; }

        public int right { get; set; }
    }
    #endregion

2: 创建赫夫曼树,原理在上面已经解释过了,就是一步一步的向上搭建,这里要注意的二个性质定理:

         当叶子节点为n个,则需要n-1步就能搭建赫夫曼树。

         当叶子节点为n个,则赫夫曼树的节点总数为:(2*n)-1个。

复制代码 代码如下:

#region 赫夫曼树的创建
        /// <summary>
/// 赫夫曼树的创建
/// </summary>
/// <param name="huffman">赫夫曼树</param>
/// <param name="leafnum">叶子节点</param>
/// <param name="weight">节点权重</param>
        public huffmantree[] createtree(huffmantree[] huffman, int leafnum, int[] weight)
        {
            //赫夫曼树的节点总数
            int huffmannode = 2 * leafnum - 1;

            //初始化节点,赋予叶子节点值
            for (int i = 0; i < huffmannode; i++)
            {
                if (i < leafnum)
                {
                    huffman[i].weight = weight[i];
                }
            }

            //这里面也要注意,4个节点,其实只要3步就可以构造赫夫曼树
            for (int i = leafnum; i < huffmannode; i++)
            {
                int minindex1;
                int minindex2;
                selectnode(huffman, i, out minindex1, out minindex2);

                //最后得出minindex1和minindex2中实体的weight最小
                huffman[minindex1].parent = i;
                huffman[minindex2].parent = i;

                huffman[i].left = minindex1;
                huffman[i].right = minindex2;

                huffman[i].weight = huffman[minindex1].weight + huffman[minindex2].weight;
            }

            return huffman;
        }
        #endregion

        #region 选出叶子节点中最小的二个节点
        /// <summary>
/// 选出叶子节点中最小的二个节点
/// </summary>
/// <param name="huffman"></param>
/// <param name="searchnodes">要查找的结点数</param>
/// <param name="minindex1"></param>
/// <param name="minindex2"></param>
        public void selectnode(huffmantree[] huffman, int searchnodes, out int minindex1, out int minindex2)
        {
            huffmantree minnode1 = null;

            huffmantree minnode2 = null;

            //最小节点在赫夫曼树中的下标
            minindex1 = minindex2 = 0;

            //查找范围
            for (int i = 0; i < searchnodes; i++)
            {
                ///只有独根树才能进入查找范围
                if (huffman[i].parent == 0)
                {
                    //如果为null,则认为当前实体为最小
                    if (minnode1 == null)
                    {
                        minindex1 = i;

                        minnode1 = huffman[i];

                        continue;
                    }

                    //如果为null,则认为当前实体为最小
                    if (minnode2 == null)
                    {
                        minindex2 = i;

                        minnode2 = huffman[i];

                        //交换一个位置,保证minindex1为最小,为后面判断做准备
                        if (minnode1.weight > minnode2.weight)
                        {
                            //节点交换
                            var temp = minnode1;
                            minnode1 = minnode2;
                            minnode2 = temp;

                            //下标交换
                            var tempindex = minindex1;
                            minindex1 = minindex2;
                            minindex2 = tempindex;

                            continue;
                        }
                    }
                    if (minnode1 != null && minnode2 != null)
                    {
                        if (huffman[i].weight <= minnode1.weight)
                        {
                            //将min1临时转存给min2
                            minnode2 = minnode1;
                            minnode1 = huffman[i];

                            //记录在数组中的下标
                            minindex2 = minindex1;
                            minindex1 = i;
                        }
                        else
                        {
                            if (huffman[i].weight < minnode2.weight)
                            {
                                minnode2 = huffman[i];

                                minindex2 = i;
                            }
                        }
                    }
                }
            }
        }
        #endregion

3:对哈夫曼树进行编码操作,形成一套“模板”,效果跟asc模板一样,不过一个是不等长,一个是等长。

复制代码 代码如下:

#region 赫夫曼编码
        /// <summary>
/// 赫夫曼编码
/// </summary>
/// <param name="huffman"></param>
/// <param name="leafnum"></param>
/// <param name="huffmancode"></param>
        public string[] huffmancoding(huffmantree[] huffman, int leafnum)
        {
            int current = 0;

            int parent = 0;

            string[] huffmancode = new string[leafnum];

            //四个叶子节点的循环
            for (int i = 0; i < leafnum; i++)
            {
                //单个字符的编码串
                string codetemp = string.empty;

                current = i;

                //第一次获取最左节点
                parent = huffman[current].parent;

                while (parent != 0)
                {
                    //如果父节点的左子树等于当前节点就标记为0
                    if (current == huffman[parent].left)
                        codetemp += "0";
                    else
                        codetemp += "1";

                    current = parent;
                    parent = huffman[parent].parent;
                }

                huffmancode[i] = new string(codetemp.reverse().toarray());
            }
            return huffmancode;
        }
        #endregion

4:模板生成好了,我们就要对指定的测试数据进行压缩处理

复制代码 代码如下:

#region 对指定字符进行压缩
        /// <summary>
/// 对指定字符进行压缩
/// </summary>
/// <param name="huffmancode"></param>
/// <param name="alphabet"></param>
/// <param name="test"></param>
        public string encode(string[] huffmancode, string[] alphabet, string test)
        {
            //返回的0,1代码
            string encodestr = string.empty;

            //对每个字符进行编码
            for (int i = 0; i < test.length; i++)
            {
                //在模版里面查找
                for (int j = 0; j < alphabet.length; j++)
                {
                    if (test[i].tostring() == alphabet[j])
                    {
                        encodestr += huffmancode[j];
                    }
                }
            }

            return encodestr;
        }
        #endregion

5: 最后也就是对压缩的数据进行还原操作。

复制代码 代码如下:

#region 对指定的二进制进行解压
        /// <summary>
/// 对指定的二进制进行解压
/// </summary>
/// <param name="huffman"></param>
/// <param name="leafnum"></param>
/// <param name="alphabet"></param>
/// <param name="test"></param>
/// <returns></returns>
        public string decode(huffmantree[] huffman, int huffmannodes, string[] alphabet, string test)
        {
            string decodestr = string.empty;

            //所有要解码的字符
            for (int i = 0; i < test.length; )
            {
                int j = 0;
                //赫夫曼树结构模板(用于循环的解码单个字符)
                for (j = huffmannodes - 1; (huffman[j].left != 0 || huffman[j].right != 0); )
                {
                    if (test[i].tostring() == "0")
                    {
                        j = huffman[j].left;
                    }
                    if (test[i].tostring() == "1")
                    {
                        j = huffman[j].right;
                    }
                    i++;
                }
                decodestr += alphabet[j];
            }
            return decodestr;
        }

        #endregion

最后上一下总的运行代码

复制代码 代码如下:

using system;
using system.collections.generic;
using system.linq;
using system.text;

namespace huffmantree
{
    class program
    {
        static void main(string[] args)
        {
            //有四个叶节点
            int leafnum = 4;

            //赫夫曼树中的节点总数
            int huffmannodes = 2 * leafnum - 1;

            //各节点的权值
            int[] weight = { 5, 7, 2, 13 };

            string[] alphabet = { "a", "b", "c", "d" };

            string testcode = "dbdbdabdcdadbdadbdadacdbdbd";

            //赫夫曼树用数组来保存,每个赫夫曼都作为一个实体存在
            huffmantree[] huffman = new huffmantree[huffmannodes].select(i => new huffmantree() { }).toarray();

            huffmantreemanager manager = new huffmantreemanager();

            manager.createtree(huffman, leafnum, weight);

            string[] huffmancode = manager.huffmancoding(huffman, leafnum);

            for (int i = 0; i < leafnum; i++)
            {
                console.writeline("字符:{0},权重:{1},编码为:{2}", alphabet[i], huffman[i].weight, huffmancode[i]);
            }

            console.writeline("原始的字符串为:" + testcode);

            string encode = manager.encode(huffmancode, alphabet, testcode);

            console.writeline("被编码的字符串为:" + encode);

            string decode = manager.decode(huffman, huffmannodes, alphabet, encode);

            console.writeline("解码后的字符串为:" + decode);
        }
    }

    #region 赫夫曼树结构
    /// <summary>
/// 赫夫曼树结构
/// </summary>
    public class huffmantree
    {
        public int weight { get; set; }

        public int parent { get; set; }

        public int left { get; set; }

        public int right { get; set; }
    }
    #endregion

    /// <summary>
/// 赫夫曼树的操作类
/// </summary>
    public class huffmantreemanager
    {
        #region 赫夫曼树的创建
        /// <summary>
/// 赫夫曼树的创建
/// </summary>
/// <param name="huffman">赫夫曼树</param>
/// <param name="leafnum">叶子节点</param>
/// <param name="weight">节点权重</param>
        public huffmantree[] createtree(huffmantree[] huffman, int leafnum, int[] weight)
        {
            //赫夫曼树的节点总数
            int huffmannode = 2 * leafnum - 1;

            //初始化节点,赋予叶子节点值
            for (int i = 0; i < huffmannode; i++)
            {
                if (i < leafnum)
                {
                    huffman[i].weight = weight[i];
                }
            }

            //这里面也要注意,4个节点,其实只要3步就可以构造赫夫曼树
            for (int i = leafnum; i < huffmannode; i++)
            {
                int minindex1;
                int minindex2;
                selectnode(huffman, i, out minindex1, out minindex2);

                //最后得出minindex1和minindex2中实体的weight最小
                huffman[minindex1].parent = i;
                huffman[minindex2].parent = i;

                huffman[i].left = minindex1;
                huffman[i].right = minindex2;

                huffman[i].weight = huffman[minindex1].weight + huffman[minindex2].weight;
            }

            return huffman;
        }
        #endregion

        #region 选出叶子节点中最小的二个节点
        /// <summary>
/// 选出叶子节点中最小的二个节点
/// </summary>
/// <param name="huffman"></param>
/// <param name="searchnodes">要查找的结点数</param>
/// <param name="minindex1"></param>
/// <param name="minindex2"></param>
        public void selectnode(huffmantree[] huffman, int searchnodes, out int minindex1, out int minindex2)
        {
            huffmantree minnode1 = null;

            huffmantree minnode2 = null;

            //最小节点在赫夫曼树中的下标
            minindex1 = minindex2 = 0;

            //查找范围
            for (int i = 0; i < searchnodes; i++)
            {
                ///只有独根树才能进入查找范围
                if (huffman[i].parent == 0)
                {
                    //如果为null,则认为当前实体为最小
                    if (minnode1 == null)
                    {
                        minindex1 = i;

                        minnode1 = huffman[i];

                        continue;
                    }

                    //如果为null,则认为当前实体为最小
                    if (minnode2 == null)
                    {
                        minindex2 = i;

                        minnode2 = huffman[i];

                        //交换一个位置,保证minindex1为最小,为后面判断做准备
                        if (minnode1.weight > minnode2.weight)
                        {
                            //节点交换
                            var temp = minnode1;
                            minnode1 = minnode2;
                            minnode2 = temp;

                            //下标交换
                            var tempindex = minindex1;
                            minindex1 = minindex2;
                            minindex2 = tempindex;

                            continue;
                        }
                    }
                    if (minnode1 != null && minnode2 != null)
                    {
                        if (huffman[i].weight <= minnode1.weight)
                        {
                            //将min1临时转存给min2
                            minnode2 = minnode1;
                            minnode1 = huffman[i];

                            //记录在数组中的下标
                            minindex2 = minindex1;
                            minindex1 = i;
                        }
                        else
                        {
                            if (huffman[i].weight < minnode2.weight)
                            {
                                minnode2 = huffman[i];

                                minindex2 = i;
                            }
                        }
                    }
                }
            }
        }
        #endregion

        #region 赫夫曼编码
        /// <summary>
/// 赫夫曼编码
/// </summary>
/// <param name="huffman"></param>
/// <param name="leafnum"></param>
/// <param name="huffmancode"></param>
        public string[] huffmancoding(huffmantree[] huffman, int leafnum)
        {
            int current = 0;

            int parent = 0;

            string[] huffmancode = new string[leafnum];

            //四个叶子节点的循环
            for (int i = 0; i < leafnum; i++)
            {
                //单个字符的编码串
                string codetemp = string.empty;

                current = i;

                //第一次获取最左节点
                parent = huffman[current].parent;

                while (parent != 0)
                {
                    //如果父节点的左子树等于当前节点就标记为0
                    if (current == huffman[parent].left)
                        codetemp += "0";
                    else
                        codetemp += "1";

                    current = parent;
                    parent = huffman[parent].parent;
                }

                huffmancode[i] = new string(codetemp.reverse().toarray());
            }
            return huffmancode;
        }
        #endregion

        #region 对指定字符进行压缩
        /// <summary>
/// 对指定字符进行压缩
/// </summary>
/// <param name="huffmancode"></param>
/// <param name="alphabet"></param>
/// <param name="test"></param>
        public string encode(string[] huffmancode, string[] alphabet, string test)
        {
            //返回的0,1代码
            string encodestr = string.empty;

            //对每个字符进行编码
            for (int i = 0; i < test.length; i++)
            {
                //在模版里面查找
                for (int j = 0; j < alphabet.length; j++)
                {
                    if (test[i].tostring() == alphabet[j])
                    {
                        encodestr += huffmancode[j];
                    }
                }
            }

            return encodestr;
        }
        #endregion

        #region 对指定的二进制进行解压
        /// <summary>
/// 对指定的二进制进行解压
/// </summary>
/// <param name="huffman"></param>
/// <param name="leafnum"></param>
/// <param name="alphabet"></param>
/// <param name="test"></param>
/// <returns></returns>
        public string decode(huffmantree[] huffman, int huffmannodes, string[] alphabet, string test)
        {
            string decodestr = string.empty;

            //所有要解码的字符
            for (int i = 0; i < test.length; )
            {
                int j = 0;
                //赫夫曼树结构模板(用于循环的解码单个字符)
                for (j = huffmannodes - 1; (huffman[j].left != 0 || huffman[j].right != 0); )
                {
                    if (test[i].tostring() == "0")
                    {
                        j = huffman[j].left;
                    }
                    if (test[i].tostring() == "1")
                    {
                        j = huffman[j].right;
                    }
                    i++;
                }
                decodestr += alphabet[j];
            }
            return decodestr;
        }

        #endregion
    }
}

算法系列15天速成——第十三天 树操作【下】