二叉树的建立+哈夫曼树

一、建树

1. 先序遍历建树

还有parent的写法

string s;int idx=-1;    //字符串s为树先序遍历的结果
struct NODE{
	char data;
	NODE *left=nullptr;
    NODE *right=nullptr;
    //NODE *parent=nullptr;
};
NODE* creat(){	
    idx++;
	if(s[idx]=='0') return NULL;
	else{
	    NODE*p=new NODE();
		p->data=s[idx];
		p->left=creat();    
        //if(p->left) p->left->parent=p;
        p->right=creat(); 
        //if(p->right) p->right->parent=p;   
		return p;
	}
}

最后返回的就是根节点啦，NODE* root=creat();

2. 数组建树

struct Tree{
	int data=0,l=0,r=0;
}Tr[100];
int main(){
	int n,x;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>x;
		if(x){
			Tr[i].data=x;
			if(2*i<=n)Tr[i].l=2*i;
			if(2*i+1<=n)Tr[i].r=2*i+1;
		}	
	}
}

二、三种遍历

其实就是输出时机不一样而已啦

void PreOrder(Node *t) {
	cout << t->data;
	if (t->leftChild) PreOrder(t->leftChild);
	if (t->rightChild) PreOrder(t->rightChild);
}
void InOrder(Node *t) {
	if (t->leftChild) InOrder(t->leftChild);
	cout << t->data;
	if (t->rightChild) InOrder(t->rightChild);
}
void PostOrder(Node *t) {
	if (t->leftChild) PostOrder(t->leftChild);
	if (t->rightChild) PostOrder(t->rightChild);
	cout << t->data;
}

三、求树的高度

这里的边界条件必须得是当前节点为空，不能是叶子结点

int dfs(NODE*now){
	if(!now) return 0;
	return max(dfs(now->left),dfs(now->right))+1;
}

四、哈夫曼树

哈夫曼树的构造+编码+解码

#include <iostream>
using namespace std;
//Huffman树结点结构
class HuffNode {	//哈夫曼树的结点结构
public:
    char letter;    //结点对应的字符
	int weight;		//权值
	int parent;		//双亲下标
	int lchild;	//左孩子下标
	int rchild;	//右孩子下标
};
//Huffman树结构
class HuffMan {
private:
	int len;		//结点总数，等于lnum*2-1
	int lnum;		//叶子数量
	HuffNode *HuffTree;	//保存构建后的赫夫曼树信息
	void selectMin(int n, int &x1, int &x2);  
//函数selectMin是从已生成的n个结点中(包含叶子)，选出未选的且权值最小的两个结点的下标
//两个下标结果保存在x1和x2中
//第一小权值的结点下标保存在x1，第二小权值的结点下标保存在x2
    string *HuffCode; //保存叶子的赫夫曼编码
public:
	HuffMan(int n,int w[],char c[]); //输入叶子数量和叶子权重和叶子对应的字母，初始化HuffTree
	void buildTree();		//构建赫夫曼树，保存在HuffTree中
	void Coding();			//生成赫夫曼编码，保存在HuffCode或HC中
	void printCode();		//输出赫夫曼编码
	void Decoding(string cs);//赫夫曼解码 
	~HuffMan();				//回收空间
};
void HuffMan::selectMin(int n, int &x1, int &x2) {
	int min1 = 1e6, min2 = 1e6;
	for (int i = 1; i <= n; i++) {
		if (HuffTree[i].parent)
			continue;
		if (HuffTree[i].weight < min1) {
			if(min1 < min2){
				x2 = x1;
				min2 = min1;
			}
			x1 = i;
			min1 = HuffTree[i].weight ;
		}
		else if (HuffTree[i].weight < min2) {
			x2 = i;
			min2 = HuffTree[i].weight ;
		}
	}
}

HuffMan::HuffMan(int n, int w[], char c[]) {
	len = 2 * n - 1;
	lnum = n;
	HuffTree = new HuffNode[len + 1];
	for (int i = 1; i <= len; i++) {
		HuffTree[i].lchild = 0;
		HuffTree[i].rchild = 0;
		HuffTree[i].parent = 0;
	}
	for (int i = 1; i <= n; i++) {
		HuffTree[i].weight = w[i - 1];
        HuffTree[i].letter = c[i - 1];
	}
}

void HuffMan::buildTree() {
	int n = lnum;
	for (int i = lnum + 1; i <= len; i++) {
		int x1=-1, x2=-1;
		selectMin(i - 1, x1, x2);
		HuffTree[x1].parent = i, HuffTree[x2].parent = i;
		HuffTree[i].lchild = x1, HuffTree[i].rchild = x2;
		HuffTree[i].weight = HuffTree[x1].weight + HuffTree[x2].weight;
	}
}

void HuffMan::printCode() {
	for (int i = 1; i <= lnum; i++) {
		cout << HuffTree[i].letter << "-" << HuffCode[i] << endl;
	}
}

void HuffMan::Coding() {
	HuffCode = new string[lnum + 1];
	for (int i = 1; i <= lnum; i++) {
		int p = i;
		while (HuffTree[p].parent) {
			if (HuffTree[HuffTree[p].parent].lchild == p)
				HuffCode[i] = '0' + HuffCode[i];
			else
				HuffCode[i] = '1' + HuffCode[i];
			p = HuffTree[p].parent;
		}
	}
}

void HuffMan::Decoding(string cs) {
	int p = len;
	string ans;
	for (int i = 0; i < cs.size(); i++) {
		if (cs[i] == '0')
			p = HuffTree[p].lchild;
		else
			p = HuffTree[p].rchild;
		if (i == cs.size() - 1 && (HuffTree[p].lchild || HuffTree[p].rchild)) {	//无解输出error 
			cout << "error" << endl;
			return;
		}
		if (!HuffTree[p].lchild && !HuffTree[p].rchild) {
			ans = ans + HuffTree[p].letter;
			p = len;
		}
	}
	cout << ans << endl;
}

HuffMan::~HuffMan() {
	delete []HuffTree;
	delete []HuffCode;
}

int main(void)
{	int n, wt[100];
	char ct[100];
	string cstr;
	cin>>n;
	for(int i=0;i<n;i++)
		cin>>wt[i];
    for(int i=0;i<n;i++)
		cin>>ct[i];
	HuffMan huff(n,wt,ct);
	huff.buildTree();    //构建哈夫曼树
	huff.Coding();       //编码
	huff.printCode(); 
    cin>>cstr;
	huff.Decoding(cstr); //哈夫曼解码
	return 0;
}