24 哈夫曼树的建立(二叉链表)

24 哈夫曼树的建立(二叉链表)

作者: 冯向阳时间限制: 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 total;
struct student
{
	string code="";
	char data=0;
	int weight=-1;
	int parent=-1;
	int left=-1;
	int right=-1;
};//这些数据默认为0 等会初始化的时候就更方便 不用再重新给初始化他们赋值为0




void select(student tree[], int n, int& s1, int& s2);



void input_data(student tree[], int n)//输入我们哈夫曼树的数据 但还没开始构建哈夫曼树
{
	for (int j = 0; j < n; ++j)
	{
	
		cin >> tree[j].data;
	}

	for (int j = 0; j < n; ++j)
	{
		
		cin >> tree[j].weight;
	}

}

void creat(student tree[], int n)//构建我们的哈夫曼树 但要用到select
{
	int valuemin1 = 0;
	int valuemin2 = 0;
	for (int i = n; i < total; i++)
	{
		select(tree, i, valuemin1, valuemin2);
		/*该select函数运行过后 作用是给valuemin1 valuuemin2赋值
		valuemin1成为了所有还未参与构建哈夫曼树的节点中 拥有最小权重的结点下标
		valuemin2成为了所有还未参与构建哈夫曼树的节点中 拥有次小权重的结点下标
		*/


		//此时i的下标已经是新构建出来的结点了 
		//以下两行代码的意思比如 有叶子结点 2 3 4 5  当i=4时,说明是新节点 该新节点是由2 3结点构成 所以该结点值为5,2 3的parent是该节点的下标所以2 3的parent等于4
		tree[valuemin1].parent = i;
		tree[valuemin2].parent = i;
		//-----------------------------

		tree[i].left = valuemin1;
		tree[i].right = valuemin2;
		//-------------------------------
		tree[i].weight = tree[valuemin1].weight + tree[valuemin2].weight;//i结点的权重为两个子节点的合

	}
}

void select(student tree[], int n, int& s1, int& s2) {
	int min=0;
	
	for (int i = 1; i <= n; i++) 
	{
		if (tree[i].parent == -1) //为什么要设置这个条件?
			//因为parent等于0时 代表这个结点还没参与哈夫曼树的构建 说明还是个零散的结点(散结点)所谓散结点就是还没参与哈夫曼树构造的结点 但你要寻找范围只能是在还没参与的结点里面寻找
		{
			min = i;
			break;
		}
	}

	for (int j = 0; j < n; ++j) 
	{
		if (tree[j].parent == -1) //在散结点中寻找 所谓散结点就是还没参与哈夫曼树构造的结点 这类节点parent为0
		{
			if (tree[j].weight < tree[min].weight)
				min = j;
		}
	}
	s1 = min;

	for (int i = 0; i < n; ++i) 
	{
		   //首先寻找范围必须是零散的结点 还没参与构建哈夫曼树 
			//parent=0说明是零散结点
			//由于s1的值已经代表第一小结点了 所以i不能等于s1
		if (tree[i].parent == -1 && i != s1)
		{
			min = i;
			break;
		}
	}
	for (int j = 0; j <n; ++j) 
	{
		if (tree[j].parent == -1 && j != s1) 
		{
			if (tree[j].weight < tree[min].weight)
				min = j;
		}
	}
	s2 = min;//s2是第二小权重结点的代号(下标)
}

void levelscan(student tree[],int n)
{
	queue<student> m;
	m.push(tree[2 * n - 2]);
	student p;
	while (!m.empty())
	{
		p = m.front();
		if(p.data!=0)
		cout <<p.data;
		cout <<"(" << p.weight << ") ";
		m.pop();
		if (p.left != -1)
		{
			m.push(tree[p.left]);
		}
		if (p.right != -1)
		{
			m.push(tree[p.right]);
		}
			

	}
}
void frontscan(student T,student tree[])
{
	if (T.data != 0)
	{
		cout << T.data;
	}
	cout << "(" << T.weight << ")"<<" ";
	if (T.left != -1)
	{
		frontscan(tree[T.left],tree);
	}
	if (T.right != -1)
	{
		frontscan(tree[T.right],tree);
	}


}

void midscan(student T, student tree[])
{
	if (T.left != -1)
	{
		midscan(tree[T.left], tree);
	}
	if (T.data != 0)
	{
		cout << T.data;
	}
	cout << "(" << T.weight << ")" << " ";	
	if (T.right != -1)
	{
		midscan(tree[T.right], tree);
	}
}

void lastscan(student T, student tree[])
{
	if (T.left != -1)
	{
		lastscan(tree[T.left], tree);
	}
	
	if (T.right != -1)
	{
		lastscan(tree[T.right], tree);
	}
	if (T.data != 0)
	{
		cout << T.data;
	}
	cout << "(" << T.weight << ")" << " ";
}

void tt(int m[])
{
	for (int i = 0; i < 10; i++)
	{
		cin >> m[i];
	}
}

void Huffman_code(student &T,student tree[],string s="0")
{
	if (T.data != '1') {
		string a = s.substr(1, s.size() - 1);
		T.code += a;
	}
	if (T.left != -1) Huffman_code(tree[T.left],tree, s + "0");
	if (T.left != -1) Huffman_code(tree[T.right], tree, s + "1");
}
int main()
{

	int n = 0;
	cin >> n;





	total = 2 * n - 1;
	student tree[100];

	input_data(tree, n);//输入我们哈夫曼树的数据 但还没开始构建哈夫曼树



	creat(tree, n);//构建我们的哈夫曼树

	levelscan(tree, n);
	cout << endl;
	frontscan(tree[2 * n - 2],tree);
	cout << endl;
	midscan(tree[2 * n - 2], tree);
	cout << endl;
	lastscan(tree[2 * n - 2], tree);
	cout << endl;
	Huffman_code(tree[2 * n - 2], tree);
	cout << endl;
	for (int i = 0; i < n; ++i)
	{
		if (tree[i].data != '1')
		{
			cout << tree[i].data << ":" << tree[i].code;
			if(i!=n-1)
			cout << endl;
		}
	}
	return 0;
}

评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杨骅麟(Hadrain Young)

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值