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

最新推荐文章于 2023-05-16 20:44:16 发布
最新推荐文章于 2023-05-16 20:44:16 发布
阅读量2.4k 收藏 2
点赞数
分类专栏： 算法系列 工作心得 算法系列15天速成 文章标签： 算法 string null class 存储 manager
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m13666368773/article/details/7530356
版权
今天说下最后一种树，大家可否知道，文件压缩程序里面的核心结构，核心算法是什么？或许你知道，他就运用了赫夫曼树。

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

 

一  概念

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

 

    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

 

最后上一下总的运行代码

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


 


m13666368773
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Object-C一日速成——基础知识
weixin_41473206的博客
05-29 3289
现在是北京时间2:33pm，今天是只有一节早课的一天，所以我坐在咖啡馆，悠闲又自在。搭建了一上午的环境后，我终于要开始写作业喽~ 文章目录一、第二章实验报告1.1实验目的1.2实验要求1.3 实验内容二、第五章实验报告2.1 实验目标2.2 实验要求2.3 实验内容三、第六章实验报告3.1实验目的3.2实验要求3.3 实验内容四、第七章实验报告7.1实验目的7.2实验要求7.3 实验内容五、第...
Object-C一日速成——环境搭建
weixin_41473206的博客
05-29 437
要我说，想要学习一门语言，搭建好相关的环境可以达到事半功倍的效果，那么今天我们就来聊一聊关于在windows系统上搭建Object-C语言编程环境的那些事。 文章目录一、基于CodeBlocks的Object-C编程环境搭建1.1 CodeBlocks？那个只会写C语言HelloWorld小白才用的软件？1.2 CodeBlocks能运行Object-C程序？1.3 CodeBlocks搭建O...
算法系列15天速成——第十五天 图【下】（大结局）
weixin_33991727的博客
12-26 147
      今天是大结局，说下“图”的最后一点东西，“最小生成树“和”最短路径“。   一： 最小生成树 1. 概念     首先看如下图，不知道大家能总结点什么。     对于一个连通图G，如果其全部顶点和一部分边构成一个子图G1，当G1满足：        ① 刚好将图中所有顶点连通。②顶点不存在回路。则称G1就是G的“生成树”。            其实一句话总结就是：生成...
算法系列15天速成——第十四天 图【上】
weixin_34252686的博客
12-24 107
         今天来分享一下图，这是一种比较复杂的非线性数据结构，之所以复杂是因为他们的数据元素之间的关系是任意的，而不像树那样 被几个性质定理框住了，元素之间的关系还是比较明显的，图的使用范围很广的，比如网络爬虫，求最短路径等等，不过大家也不要胆怯， 越是复杂的东西越能体现我们码农的核心竞争力。               既然要学习图，得要遵守一下图的游戏规则。 一： 概念 ...
算法系列15天速成[索引]
weixin_30678349的博客
12-30 185
算法系列15天速成——第一天 七大经典排序【上】 算法系列15天速成——第二天 七大经典排序【中】 算法系列15天速成——第三天 七大经典排序【下】 算法系列15天速成——第四天 五大经典查找【上】 算法系列15天速成——第五天 五大经典查找【中】 算法系列15天速成——第六天 五大经典查找【下】 算法系列15天速成——第七天 线性表【上...
算法系列15天速成——第十一天 树操作（上）
weixin_30895603的博客
12-11 108
最近项目赶的紧，歇了一个星期没写博客了，趁周末继续写这个系列。 先前我们讲的都是“线性结构”，他的特征就是“一个节点最多有一个”前驱“和一个”后继“。那么我们今天讲的树会是怎样的呢？ 我们可以对”线性结构“改造一下，变为”一个节点最多有一个"前驱“和”多个后继“。哈哈，这就是我们今天说的”树“。 一： 树 我们思维中的”树“就是一种枝繁叶茂的...
算法系列15天速成——第五天 五大经典查找【中】
04-27 3539
大家可否知道，其实查找中有一种O(1)的查找，即所谓的秒杀。   哈希查找：       对的，他就是哈希查找，说到哈希，大家肯定要提到哈希函数，呵呵，这东西已经在我们脑子里面形成 固有思维了。大家一定要知道“哈希“中的对应关系。      比如说： ”5“是一个要保存的数，然后我丢给哈希函数，哈希函数给我返回一个”2"，那么此时的”5“ 和“2”就建立一种对应关系，这种关系就是所谓
数据结构算法
05-02
第二天 平衡二叉树 6天通吃树结构—— 第一天 二叉查找树 算法速成系列(15)算法系列15天速成——第十五天 图【下】（大结局） 算法系列15天速成——第十四天 图【上】 算法系列15天速成——第十三天 树操作【下】 ...
哈夫曼编码及解码（左子树权值小于右子树）
12-29
编程实现给定权值集合下构造相应哈夫曼树的算法，并解决以下问题： 有一电文共使用五种字符a,b,c,d,e,其出现频率依次为4,7,5,2,9。 (1)构造对应的编码哈夫曼树(要求左子树根结点的权小于等于右子树根结点的权)。 (2)给出每个字符的哈夫曼编码。 (3)译出编码系列11000111000101011的相应电文。
算法系列15天速成——第十二天 树操作【中】
weixin_33997389的博客
12-12 89
      先前说了树的基本操作，我们采用的是二叉链表来保存树形结构，当然二叉有二叉的困扰之处，比如我想找到当前结点 的“前驱”和“后继”，那么我们就必须要遍历一下树，然后才能定位到该“节点”的“前驱”和“后继”，每次定位都是O（n），这 不是我们想看到的，那么有什么办法来解决呢？    （1） 在节点域中增加二个指针域，分别保存“前驱”和“后继”，那么就是四叉链表了，哈哈，还是有点浪费空...
树及其操作（C语言版）
坚持是一种品质
09-23 1万+
树及其操作（C语言版）标签（空格分隔）： 数据结构 树树定义和性质： 树的定义：树是n个（n>=0）有限节点组成一个具有层次关系的集合。 根及子树：在任意一个非空树中，有且仅有一个特定的称为根的结点，当n>1时，其余结点又可以分为m（m>0）个互不相交的有限集T1,T2,...Tm T_1,T_2,...T_m,其中每一个集合本身又是一颗树，并称为根的子树。 基本操作：InitTree(&T):构造
哈夫曼树（结合王卓老师课程内容）
最新发布
Qiutan22的博客
05-16 2732
所以哈夫曼树中共有2n-1个结点，且其所有的分支结点的度均不为1.
软件设计师 --哈夫曼树的一个经典问题
萝卜地里的兔子的博客
04-23 8048
题目如下：有很多人反应，他们怎么做都做不出正确的答案，结果发过他们画的哈夫曼树的图以后，发现图完全是错误的；如下图所示：为什么错误的，因为在遇到有两个权重为17的树的时候，没有遵循选择矮树的原则；正确的哈夫曼树如下：这样就能得出正确答案了。总结：在绘制哈夫曼树的时候，要遵循一下原则：（1）左子树的权重小于右子树（这个一般人都会注意的，因为哈夫曼树是二叉树，是有序的）（2）遇到权重相同的，选比较矮的...
哈夫曼树及其实现
Beat_IT的博客
08-08 421
首先了解一下什么是哈夫曼树： 给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，即权值较大的结点离根较近。 哈夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度（若根结点为0层，叶结点到根结...
哈夫曼树（最优二叉树）及其Java实现
热门推荐
生命在于折腾
08-18 1万+
一、定义 一些定义： 节点之间的路径长度：在树中从一个结点到另一个结点所经历的分支，构成了这两个结点间的路径上的经过的分支数称为它的路径长度 树的路径长度：从树的根节点到树中每一结点的路径长度之和。在结点数目相同的二叉树中，完全二叉树的路径长度最短。 结点的权：在一些应用中，赋予树中结点的一个有某种意义的实数。 结点的带权路径长度：结点到树根之间的路径长度与该结点
哈夫曼树
wust_ZJX的专栏
04-07 997
1002: 哈夫曼树 Time Limit: 1 Sec  Memory Limit: 65535 MB   64bit IO Format: %lld Submitted: 13  Accepted: 6 [Submit][Status][Web Board] Description 根据给定的若干权值可以构造出一颗哈夫曼树。构造的哈夫曼树可能不唯一，但是按照下面的选取原
哈弗曼树与哈弗曼树编码
行而不辍，未来可期 - King
06-02 6958
哈弗曼（Huffman）树，也称最优树，是一类带全路径长度最短的树，在实际中有广泛的应用，也是二叉树的一个具体应用。 在哈夫曼树的定义中，涉及到了路径、路径长度、权等概念，下面先给出概念的定义。 一、概念与定义 路径：从树的一个结点到另一个结点的分支构成这两个结点之间的路径，对于哈夫曼树特指从根节点到某节点的路径。 路径长度：路径上的分支数目叫做路径长度。 树的路径长度：从树根到每一结点
算法15天速成：七大经典排序——冒泡排序对决快速排序
"算法系列15天速成——第一天七大经典排序【上】 在这个15天的算法速成系列中，我们将深入探讨数据结构与算法，特别是重点讲解树、图、堆栈、队列等核心概念。算法是编程的基础，就像剑客手中的利剑，能够高效地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值