链表之哈夫曼树

在学习了链表的基本使用方法后，我尝试使用链表构建了比较常见的一种树形结构： 哈夫曼树

这里不对哈夫曼树进行介绍，直接开始
首先是定义子节点

class node {
	public:
		char c;
		int num;
		node* left;           //叶子左节点 
		node* right;          //叶子右节点 
		node(){
			left=NULL;
			right=NULL;
		}
		void set(char c,int num,node* left,node* right){
			this->c=c;
			this->num=num;
			this->left=left;
			this->right=right;
		}
};

//定义一个类来存储编码

class map{
	
	public:
	    string encoding;      // 0 1 转码 
	    char c;               // 转码字符 
	
};

//这里是一个自定义的函数求数组的长度

//批注1：
template<class T>
int length(T& arr)
{
    //cout << sizeof(arr[0]) << endl;
    //cout << sizeof(arr) << endl;
    return sizeof(arr) / sizeof(arr[0]);
}

//设置一个不重复的字符串

string NoRepeat(string sour,string noRe){
	for(int i=0;i<sour.length();i++){
		//判断字符串中是否包含一个字符 
		if(noRe.find(sour[i])==string::npos){
		//如果不包含则放入新生成的串 
			noRe+=sour[i];
		}
	}
	return noRe;
} 

//计算每一个字符的权重

node  calculate(string sour,string noRe,node nodes[]){
       	for(int i=0;i<noRe.length();i++){
       		nodes[i].c=noRe[i]; 
       		nodes[i].num=0;
       		for(int j=0;j<sour.length();j++){
       			if(nodes[i].c==sour[j]){
       				nodes[i].num++;
				   }
			   }
		   }
           //返回数组首地址 
		   return  *nodes;
	   } 

//节点类数组排序算法

node  sort(node nodes[],string noRe,int length){
	for(int i=0;i<length;i++){
		for(int j=i+1;j<length;j++){
			if(nodes[i].num>nodes[j].num){
				node temp;
				temp=nodes[i];
				nodes[i]=nodes[j];
				nodes[j]=temp;
			}
		}
	}
	//返回数组首地址 
	return *nodes;
} 

// 打印字符对应的编码

void  prints(node * z,string s,string lr){
    //判断树是向右走还是向左走 
    if(lr=="left"){
    	    //向左走编码为0 
			s+='0';
		}
		else if(lr=="right"){
			//向右走编码为1 
			s+='1';
		}
	//递归调用的条件 
	if(z->left!=NULL){
		node* i=z->left;	
		node* j=z->right;
		//向左调用 
		prints(i,s,"left");	  
		//向右调用  
	    prints(j,s,"right");

	}
	else {
		//输出编码 
	cout<<z->c<<" "<<s<<endl;
	}
} 

//建立哈夫曼树，递归生成子节点

void    setTree(node nodes[],string noRe,int length){
        	node temp;
        	//递归调用的条件 
        	if(length>2){
        		//定义一个新的数组来存储新的值 
        	node node2[length-1];
        	    //排序算法 
        	*nodes=sort(nodes,noRe,length);
        	    //让最小的值相加 
			temp.num=nodes[0].num+nodes[1].num;
			    //让temp的left和right指向叶节点 
			temp.left=&nodes[0];
			temp.right=&nodes[1]; 	
			    //将原来数组的值赋给新的数组		
			node2[0]=temp;
			for(int i=2;i<length;i++){
				node2[i-1]=nodes[i];
			}
			    //递归调用 
			setTree(node2,noRe,length-1);
		}		
		    //递归结束的条件 
		if(length==2){
			//掉用排序算法 
			*nodes=sort(nodes,noRe,length);
			temp.num=nodes[0].num+nodes[1].num;
			cout<<nodes[0].num<<" "<<nodes[1].num<<endl;
			temp.left=&nodes[0];
			temp.right=&nodes[1];
			string s="";
            string ss="";
            //批注2：
            //在这里调用print 是因为temp的值传出去后会损失一部分内容 
			prints(&temp,s,ss);			
	}		   
} 

//main()函数

int main(){
	
	string source="aabbccddeeffgg";
	//定义一个不重复的数组，例如"aabbcc"->"abc" 
	string noRepeat="";
	//这一步操作生成一个不重复的字符串 
	noRepeat=NoRepeat(source,noRepeat);
	//这一步操作定义一个节点类数组 
	node nodes[noRepeat.length()];
	//这一步操作给节点类数组赋值 
	*nodes=calculate(source,noRepeat,nodes);
	//这一步生成根节点 ，并且打印编码  
    setTree(nodes,noRepeat,noRepeat.length());
    
} 

批注1：
自定义函数为方便返回对象链表的长度，在这里并没有用到，但是这是一种普遍的方法，应该学习它并加以利用。
批注2：
对于打印时出现的异常我进行了记录，后来发现是函数结束时，对指针对象进行了回收，即使我的根节点仍然保留，但我的子节点已经被清理掉，无法通过指针寻址的方式访问。因此我选择了直接在子函数内部进行数据的打印，而舍弃了在主函数进行数据的打印。