算法系列15天速成——第十三天 树操作【下】_相关技巧

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

一  概念

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

    1： 结点的权

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

    2： 路径

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

    3： 路径长度

             一个路径上的分支数量。

    4： 树的路径长度

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

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

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

    6:   树的带权路径长度

             树中各个叶节点的路径长度*该叶节点的权的和，常用WPL(Weight Path Length)表示。

二： 构建赫夫曼树

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

         因为他的WPL是最短的，何以见得？我们可以上图说话。

现在我们做一个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"就是一颗赫夫曼树，那么大家肯定

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

 

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

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

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

第四步： 同上。

 

三： 赫夫曼编码

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

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

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

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

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

A: 111

B: 10

C: 110

D: 0

 

四： 实现

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

         第一步：构建赫夫曼树。

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

         第三步：压缩操作。

         第四步：解压操作。

 

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
    }
}

时间： 2024-11-25 23:13:12

算法系列15天速成——第十三天 树操作【下】_相关技巧的相关文章

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

   今天说下最后一种树,大家可否知道,文件压缩程序里面的核心结构,核心算法是什么?或许你知道,他就运用了赫夫曼树. 听说赫夫曼胜过了他的导师,被认为"青出于蓝而胜于蓝",这句话也是我比较欣赏的,嘻嘻.   一  概念     了解"赫夫曼树"之前,几个必须要知道的专业名词可要熟练记住啊.       1: 结点的权             "权"就相当于"重要度",我们形象的用一个具体的数字来表示,然后通过数字的大小来决定谁

算法系列15天速成——第十一天 树操作（上）

  最近项目赶的紧,歇了一个星期没写博客了,趁周末继续写这个系列.        先前我们讲的都是"线性结构",他的特征就是"一个节点最多有一个"前驱"和一个"后继".那么我们今天讲的树会是怎样的呢? 我们可以对"线性结构"改造一下,变为"一个节点最多有一个"前驱"和"多个后继".哈哈,这就是我们今天说的"树".   一: 树       我们思维

算法系列15天速成 第十一天 树操作（上）_相关技巧

先前我们讲的都是"线性结构",他的特征就是"一个节点最多有一个"前驱"和一个"后继".那么我们今天讲的树会是怎样的呢? 我们可以对"线性结构"改造一下,变为"一个节点最多有一个"前驱"和"多个后继".哈哈,这就是我们今天说的"树". 一: 树       我们思维中的"树"就是一种枝繁叶茂的形象,那么数据结构中的"树&

算法系列15天速成——第八天 线性表【下】

一:线性表的简单回顾        上一篇跟大家聊过"线性表"顺序存储,通过实验,大家也知道,如果我每次向 顺序表的头部插入元素,都会引起痉挛,效率比较低下,第二点我们用顺序存储时,容 易受到长度的限制,反之就会造成空间资源的浪费.   二:链表       对于顺序表存在的若干问题,链表都给出了相应的解决方案. 1. 概念:其实链表的"每个节点"都包含一个"数据域"和"指针域".             "数据域&

算法系列15天速成——第六天 五大经典查找【下】

大家是否感觉到,树在数据结构中大行其道,什么领域都要沾一沾,碰一碰. 就拿我们前几天学过的排序就用到了堆和今天讲的"二叉排序树",所以偏激的说,掌握的树你就是牛人了.   今天就聊聊这个"五大经典查找"中的最后一个"二叉排序树".   1. 概念:      <1> 其实很简单,若根节点有左子树,则左子树的所有节点都比根节点小.                              若根节点有右子树,则右子树的所有节点都比根节点大

算法系列15天速成 第六天 五大经典查找【下】_相关技巧

大家是否感觉到,树在数据结构中大行其道,什么领域都要沾一沾,碰一碰.就拿我们前几天学过的排序就用到了堆和今天讲的"二叉排序树",所以偏激的说,掌握的树你就是牛人了. 今天就聊聊这个"五大经典查找"中的最后一个"二叉排序树". 1. 概念:     <1> 其实很简单,若根节点有左子树,则左子树的所有节点都比根节点小.                             若根节点有右子树,则右子树的所有节点都比根节点大.     &

算法系列15天速成——第七天 线性表【上】

原文:算法系列15天速成--第七天 线性表[上]   人活在社会上不可能孤立,比如跟美女有着千丝万缕的关系,有的是一对一,有的是一对多,有的是多对多. 哈哈,我们的数据也一样,存在这三种基本关系,用术语来说就是: <1>  线性关系. <2>  树形关系. <3>  网状关系.   一: 线性表       1 概念:                  线性表也就是关系户中最简单的一种关系,一对一.                   如:学生学号的集合就是一个线性表.

算法系列15天速成——第十五天 图【下】（大结局）

一: 最小生成树 1. 概念     首先看如下图,不知道大家能总结点什么.     对于一个连通图G,如果其全部顶点和一部分边构成一个子图G1,当G1满足:        ① 刚好将图中所有顶点连通.②顶点不存在回路.则称G1就是G的"生成树".            其实一句话总结就是:生成树是将原图的全部顶点以最小的边连通的子图,这不,如下的连通图可以得到下面的两个生成树.        ② 对于一个带权的连通图,当生成的树不同,各边上的权值总和也不同,如果某个生成树的权值最小,

算法系列15天速成——第十四天 图【上】

       今天来分享一下图,这是一种比较复杂的非线性数据结构,之所以复杂是因为他们的数据元素之间的关系是任意的,而不像树那样 被几个性质定理框住了,元素之间的关系还是比较明显的,图的使用范围很广的,比如网络爬虫,求最短路径等等,不过大家也不要胆怯, 越是复杂的东西越能体现我们码农的核心竞争力.               既然要学习图,得要遵守一下图的游戏规则. 一: 概念        图是由"顶点"的集合和"边"的集合组成.记作:G=(V,E): <1