哈夫曼树的建立（二叉链表）

最新推荐文章于 2023-09-07 14:05:34 发布
最新推荐文章于 2023-09-07 14:05:34 发布
阅读量1k 收藏 6
点赞数
分类专栏： 我的dhu记录 文章标签： 链表 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nameofworld/article/details/125615700
版权

哈夫曼树的建立（二叉链表）

作者: 冯向阳时间限制: 10S章节: DS:树

截止日期: 2022-06-30 23:55:00

问题描述 :

内容：请参照二叉树的ADT模板，设计Huffman树的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的二叉树ADT原型文件，自行设计Huffman树的ADT。）

 

应用：要求设计一个算法，使用动态存储的方式，实现Huffman树的ADT。

提示：动态存储是指在新添加一个数据元素时，为它申请一个动态变量。删除一个数据元素时，释放该元素的存储空间。huffman树类的行为主要有两个：构造一棵haffuman树和获取叶子结点的Huffman编码。但由于树上的结点都是动态申请的，为此还需要一个析构函数。每个结点要保存的信息有4个：结点的值、结点的权值、左孩子指针、右孩子指针。

注意：为了保证你生成的哈夫曼树和题目的要求一致，需要遵循以下原则：

1、两个结点合并成一棵树时，权重小的结点为新树的左子树，权重大的结点为新树的右子树。

2、如果两个结点权重相等，则本来在左边的结点为新树的左子树。

3、新创建的树始终放在集合（森林）的最右边。

Huffuman类的参考定义：

/* Huffman树的结点定义 */

template<class ElemType>

struct Huffman_TreeNode{

    Huffman_TreeNode *LChild, *RChild;  //左、右孩子指针 

    ElemType data;   //结点值 

    int weight;      //结点的权值 

    Huffman_TreeNode(int w, Huffman_TreeNode *l = NULL, Huffman_TreeNode *r = NULL): weight(w), LChild(l), RChild(r){}

    Huffman_TreeNode(const ElemType d, int w, Huffman_TreeNode *l = NULL, Huffman_TreeNode *r = NULL): data(d), weight(w), LChild(l), RChild(r){}

    ElemType getData(){ return data;}  //取得结点中的数据

};

const int MAX_INT = 32767;                                  

//Huffman树 

template<class ElemType>

class Huffman_Tree{

   private:

      Huffman_TreeNode<ElemType> *root;

   public:              

      //带参数的构造函数

      Huffman_Tree(const ElemType *v, const int *w, int size);

      //析构函数

      ~Huffman_Tree(){clear(root);}

      //获取根结点 

      Huffman_TreeNode<ElemType> * GetRoot() const{ return root;}

      //前序遍历 

      bool PreOrderTraverse( Huffman_TreeNode<ElemType> *T, bool (*visit)(Huffman_TreeNode<ElemType> *T) ) const;  //前序遍历（递归）

      //中序遍历 

      bool InOrderTraverse( Huffman_TreeNode<ElemType> *T, bool (*visit)(Huffman_TreeNode<ElemType> *T) ) const;  //前序遍历（递归）

      //后序遍历 

      bool PostOrderTraverse( Huffman_TreeNode<ElemType> *T, bool (*visit)(Huffman_TreeNode<ElemType> *T) ) const;  //前序遍历（递归）

      //层次遍历

      bool LayerOrderTraverse(bool (*visit)(Huffman_TreeNode<ElemType> *T)) const;

      //删除huffman树 

      void clear(Huffman_TreeNode<ElemType> *t); 

      //查找值为x的结点的位置 （递归）

      void Location_Cursive( Huffman_TreeNode<ElemType> * root, const ElemType &x, Huffman_TreeNode<ElemType> * &location ); //采用先序遍历      

      //获取父结点（递归） 

      void GetParent_Cursive(Huffman_TreeNode<ElemType> * parent, Huffman_TreeNode<ElemType> * &x, Huffman_TreeNode<ElemType> * &result, int &flag);

      //查找从根结点到元素值为x的叶子结点的路径，路径经过的结点指针存放在顺序栈中（用于获取编码）

      void FindPath( Huffman_TreeNode<ElemType> * &x, stack<ElemType> &Q );

};

辅助函数：

（1）Huffuman树遍历用visit函数，显示结点的权值

template<class ElemType>

bool visit(Huffman_TreeNode<ElemType> * root){

     

    if(!root) return false;
    else{
       if(root->LChild || root->RChild)
           cout<<"("<<root->weight<<") ";
       else
           cout<<root->data<<"("<<root->weight<<") ";     
    }

    return true;
     

}     

（2）Huffman树用栈遍历 

template<class ElemType>

void Huffman_Tree_StackTraverse(stack<ElemType> &Q){

    char p;

    //打印顺序栈 

    int length = Q.size();

    ElemType path[length];

      

    for( int i = 0; i < length; i++){

        p = Q.top();

        Q.pop();

        path[i] = p;

    }

    for( int i = 0; i < length; i++) cout<<path[i];

}

输入说明 :

第一行：待编码的字符集的个数

第二行：待编码的字符

第三行：字符对应的权值

输出说明 :

第一行：Huffman树的层次遍历结果（非叶子结点显示形式： (结点权值)，叶子结点显示形式： 结点data(结点权值) ）

第二行：Huffman树的前序遍历结果（非叶子结点显示形式： (结点权值)，叶子结点显示形式： 结点data(结点权值) ）

第三行：Huffman树的中序遍历结果（非叶子结点显示形式： (结点权值)，叶子结点显示形式： 结点data(结点权值) ）

第四行：Huffman树的后序遍历结果（非叶子结点显示形式： (结点权值)，叶子结点显示形式： 结点data(结点权值) ）

第五行：空行

第六行开始：n个叶子结点对应的Huffuman编码（1个叶子结点的Huffman编码占一行）

输入范例 :

5
d i a n w
7 5 2 4 9
输出范例 :

(27) (11) (16) i(5) (6) d(7) w(9) a(2) n(4) 
(27) (11) i(5) (6) a(2) n(4) (16) d(7) w(9) 
i(5) (11) a(2) (6) n(4) (27) d(7) (16) w(9) 
i(5) a(2) n(4) (6) (11) d(7) w(9) (16) (27) 

d:10
i:00
a:010
n:011
w:11

#include<iostream>
#include<queue>
using namespace std;
int zong;
 typedef struct
{
    string code="";
	char te=0;
	int w=-2;
	int parent=-2;
	int l=-2;
	int r=-2;
}havetree;
void tiao(havetree T[],int n,int &X,int &J)
{
    int xiao=0;
    for(int jj=1;jj<=n;jj++)
    {
        if(T[jj].parent==-2)
        {
            xiao=jj;
            break;
        }
    }
    for (int j = 0; j < n; ++j)
	{
		if (T[j].parent == -2)
		{
			if (T[j].w < T[xiao].w)
				xiao = j;
		}
	}
	X = xiao;
	for (int i = 0; i < n; ++i)
	{
		if (T[i].parent == -2 && i != X)
		{
			xiao = i;
			break;
		}
	}
	for (int j = 0; j <n; ++j)
	{
		if (T[j].parent == -2 && j != X)
		{
			if (T[j].w< T[xiao].w)
				xiao = j;
		}
	}
	J = xiao;
}
void havema(havetree &T,havetree tree[],string s="0")
{
    if (T.te != '1') {
		string a = s.substr(1, s.size() - 1);
		T.code += a;
	}
	if (T.l != -2) havema(tree[T.l],tree, s + "0");
	if (T.l != -2) havema(tree[T.r], tree, s + "1");
}
 void ceng(havetree T[],int n)
 {
     queue<havetree> Q;
	Q.push(T[2 * n - 2]);
	havetree PPT;
	while (!Q.empty())
	{
		PPT = Q.front();
		if(PPT.te!=0)
		cout <<PPT.te;
		cout <<"(" << PPT.w<< ") ";
		Q.pop();
		if (PPT.l != -2)
		{
			Q.push(T[PPT.l]);
		}
		if (PPT.r != -2)
		{
			Q.push(T[PPT.r]);
		}
	}
 }
void qian(havetree TT,havetree T[])
{
    if (TT.te != 0)
	{
		cout << TT.te;
	}
	cout << "(" << TT.w << ")"<<" ";
	if (TT.l!= -2)
	{
		qian(T[TT.l],T);
	}
	if (TT.r != -2)
	{
		qian(T[TT.r],T);
	}
}
void zhong(havetree TT,havetree T[])
{
    if (TT.l != -2)
	{
		zhong(T[TT.l], T);
	}
	if (TT.te != 0)
	{
		cout << TT.te;
	}
	cout << "(" << TT.w<< ")" << " ";
	if (TT.r != -2)
	{
		zhong(T[TT.r],T);
	}
}
void hou(havetree TT,havetree tree[])
{
    if (TT.l != -2)
	{
		hou(tree[TT.l], tree);
	}

	if (TT.r != -2)
	{
		hou(tree[TT.r], tree);
	}
	if (TT.te != 0)
	{
		cout << TT.te;
	}
	cout << "(" << TT.w << ")" << " ";
}

int main()
{
	int num = 0;
	cin >> num;
	zong = 2 * num - 1;
	havetree T[100];
	for(int xi=0;xi<num;xi++)
    {
        cin>>T[xi].te;
    }
    for(int xi=0;xi<num;xi++)
    {
        cin>>T[xi].w;
    }
	int xiaozhi1=0;
    int xiaozhi2=0;
    for(int jj=num;jj<zong;jj++)
    {
        tiao(T,jj,xiaozhi1,xiaozhi2);
        T[xiaozhi1].parent = jj;
		T[xiaozhi2].parent = jj;
		T[jj].l= xiaozhi1;
		T[jj].r = xiaozhi2;
		T[jj].w= T[xiaozhi1].w + T[xiaozhi2].w;
    }
	ceng(T, num);
	cout << endl;
	qian(T[2*num-2],T);
	cout << endl;
	zhong(T[2*num-2],T);
	cout << endl;
	hou(T[2*num-2], T);
	cout << endl;
	havema(T[2*num-2], T);
	cout << endl;
	for (int i=0;i<num;++i)
	{
		if (T[i].te!= '1')
		{
			cout<<T[i].te<< ":" << T[i].code;
			if(i!=num-1)
			cout << endl;
		}
	}
	return 0;
}

nameofworld
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈夫曼树的创建
陈娟的博客
06-09 5275
二叉树的路径和？ 所有叶子节点路径的总和。 什么是哈夫曼树？ 路径和最短的二叉树 如何构造最优二叉树，也就是哈夫曼树 哈夫曼树的构建过程？ 1.给出一个数组，以每个元素为基础，创建一个叶子节点数组。 2.从中找出权值最小的两个节点，构建一棵树。这棵树的权值等于两个节点权值之和。左子树等于权值最小的那个节点，右子树等于权值次小的那个节点。 3.将该树的根放入节点数组中
数据结构——二叉树、哈夫曼树、堆、二叉排序树等树状结构的详细讲解与C++的实现和应用（即使没学栈和队列也可以看）
m0_70379664的博客
08-14 739
数据结构——二叉树、哈夫曼树、堆、二叉排序树等树状结构的详细讲解与C++的实现和应用（即使没学栈和队列也可以看）
c++建立二叉链表树以及哈夫曼树
04-20
理解二叉树线索化的实质是建立结点与其在相应序列中的前驱或后继之间的直接联系。二叉树的线索化过程是基于对二叉树进行遍历，而线索二叉树上的线索又为相应的遍历提供了方便
C++链表：哈夫曼树（附源码）
C语言C++学习俱乐部：765860056
10-18 1399
在开始之前先给大家介绍一下什么是哈夫曼树 哈夫曼树就是给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。 1、路径和路径长度 在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。 2、结点的权及带权路径长度 若将树中结点赋给一个有着某种含义的数值，则这...
数据结构-哈夫曼树
最新发布
sun_weitao的博客
09-07 492
计算带权路径长度方法：第一棵树：有4个结点1，3，4，5；从顶点到权重为1的点需要经过两条边；所以权重为1的结点；结点路径长度是1*2=2；其他结点从顶点到最后也是经过两条边；所以带权路径长度是1*2+3*2+4*2+5*2 = 26；第二棵树：从顶点到权重为5的结点长度是1；顶点到4的长度是2；顶点到1的长度是3；顶点到3的长度是3；所以带权路径长度是：1*5+2*4+3*1+3*3 = 25；所以称中间两棵树是哈夫曼树；或者是 最优二叉树。其他几个树带权路径的计算长度也是一样的。
哈夫曼树的建立（二叉链表
the chosen 07 的博客
06-06 487
#include<iostream> #include<algorithm> #include<cstdio> #include<string> #include<vector> #include<string.h> #include<map> #include<cmath> #include<sstream> #include<stack> #include<queue> #
19、哈夫曼树的建立（二叉链表）
windyuan~
05-31 973
问题描述 : 内容：请参照二叉树的ADT模板，设计Huffman树的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的二叉树ADT原型文件，自行设计Huffman树的ADT。） 应用：要求设计一个算法，使用动态存储的方式，实现Huffman树的ADT。 提示：动态存储是指在新添加一个数据元素时，为它申请一个动态变量。删除一个数据元素时，释放该元素的存储空间。huffma.
二叉链表实现哈夫曼树
weixin_74370136的博客
05-07 417
【代码】二叉链表实现哈夫曼树。
赫夫曼树及构成方法(链表)
m0_74469506的博客
05-18 747
赫夫曼树及构成方法(链表)
二叉树应用之哈夫曼编码(二叉链表实现)
GadyPu的专栏
11-08 4067
哈夫曼树的定义:(直接百度贴过来)给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小， 称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman tree)。哈夫曼树是带权路径长度最短的树， 权值较大的结点离根较近。具体实现定义一个结构体
哈夫曼树构建
01-08
哈夫曼树是带权值的树节点结构，且目标节点都存储在叶子节点上。下面使用Go实现哈夫曼树 哈弗曼树构建过程 将带权值的节点进行排序，形成有序的链表。 取出链表头两个节点，权值相加形成新节点，并加入上述链表中重新排序，两节点分别为构建为左右子树，新创建的节点为父节点。 重复步骤2直到链表节点为1退出构造 哈夫曼节点定义 type huffmannode struct { value interface{} //store the value of huffman tree node weight uint32 //store the weight of node } 节点实现链表的比较以
课程设计哈夫曼编码译码系统
09-20
哈夫曼编码是根据字符的使用率的高低对字符进行不等长的编码，从而使使用率高的字符占用较少的空间，从而在传输的过程中大大提高了数据的空间传输效率。本设计采用二叉链表的存储结构，建立哈夫曼树；用递归调用的方式对哈夫曼树的节点进行编码，生成与字符对应的哈夫曼编码。本设计完全采用C语言进行编程，并在VC++编译器上调试运行通过。本程序使用中文界面，并有相应的提示信息，便于操作和程序运行。
数据结构C语言 6第六章 树.zip 配套第六章 树【数据结构】学习实验
05-12
包含 huffman（建立哈夫曼树、输出哈夫曼编码、输出译码、编码原文件到编码文件，译码编码文件到新文件） 二叉树（先序建立、 递归先序遍历、递归中序遍历、递归后序遍历、 非递归先序遍历、非递归中序遍历、非递归后序遍历、 .二叉树的层次遍历） 遍历算法的应用 1.统计二叉树的结点数 2.输出二叉树的叶子结点 3.统计二叉树的叶子结点数目 4.求二叉树的高度 5.求结点的双亲 6.二叉树相似性判定 7.按树状打印二叉树 8.创建二叉链表存储的二叉树
Huffman树 及 Huffman编码 演示程序
06-29
Huffman树 及 Huffman编码 演示程序 以画图的方法形象的表示了树的构成，解决了普通控制台应用程序对树的结构表达不清的问题 编译器 VS2008
数据结构 树 哈夫曼树 遍历算法
04-27
建立一棵二叉链表树，分别输出此先根、中根和后根遍历序列 将上题编程，实现哈夫曼树的构建和哈夫曼编码的设计
用链表的方式构建哈夫曼树
summersunrain的博客
11-04 3171
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;iostream&gt; using namespace std; #define MAXSIZE 30 typedef struct node {     int data;     struct node *lchild, *rchild;     struct node...
24 哈夫曼树的建立（二叉链表）
Ultravioletrays的博客
05-12 1462
24哈夫曼树的建立（二叉链表） 作者:冯向阳时间限制:10S章节:DS:树 截止日期:2022-06-30 23:55:00 问题描述 : 内容：请参照二叉树的ADT模板，设计Huffman树的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的二叉树ADT原型文件，自行设计Huffman树的ADT。） 应用：要求设计一个算法，使用动态存储的方式，实现Huf...
链表与哈夫曼树
panghaohan的博客
03-18 423
&lt;!--[if !supportLists]--&gt;一、&lt;!--[endif]--&gt;什么是链表？ 链表是使用指针进行连接的一种数据结构，他可以提供比数组更加灵活的数据存储。 认识一下链表之前，先知道节点。 Class Node { Object data;/用于存储数据； Node next;//指向下一个的指针 } 一、哈夫曼编码 以哈夫曼树─即最...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值