种树：二叉树、二叉搜索树、AVL树、红黑树、哈夫曼树、B树、树与森林

 1.每个结点有零个或多个子结点；
 2.没有父结点的结点为根结点；
 3.每一个非根结点只有一个父结点；
 4.每个结点及其后代结点整体上可以看做是一棵树，称为当前结点的父结点的一个子树；

class TreeNode{
private:
	int val;
	TreeNode *left;
	TreeNode *right;
public:
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
}

void PreOrderTraverse(TreeNode* root){
	if(NULL == root)
		return;
	cout<<root->val;
	PreOrderTraverse(root->left);
	PreOrderTraverse(root->right);
}

void MidOrderTraverse(TreeNode* root){
	if(NULL == root)
		return;
	MidOrderTraverse(root->left);
	cout<<root->val;
	MidOrderTraverse(root->right);
}

void LastOrderTraverse(TreeNode* root){
	if(NULL == root)
		return;
	LastOrderTraverse(root->left);
	LastOrderTraverse(root->right);
	cout<<root->val;
}

给了中序那就好办了
一：看中序排列中的根节点位置在哪里，根节点前面都属于根的左子树及其后代，后面你懂得。
二：将中序序列分两段：（D、B、E）和（F、C、G）
三：明眼人一看就知道根节点左子树的“根节点”是：B
别问我为啥，问就是看前序序列的第二位
四：重复二三，直到根节点左子树排出来为止
五：同上，排出右子树

class Solution {
private:
    unordered_map<int, int> index;

public:
    TreeNode* myBuildTree(const vector<int>& preorder, const vector<int>& inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) {
        if (preorder_left > preorder_right) {
            return nullptr;
        }
        
        // 前序遍历中的第一个节点就是根节点
        int preorder_root = preorder_left;
        // 在中序遍历中定位根节点
        int inorder_root = index[preorder[preorder_root]];
        
        // 先把根节点建立出来
        TreeNode* root = new TreeNode(preorder[preorder_root]);
        // 得到左子树中的节点数目
        int size_left_subtree = inorder_root - inorder_left;
        // 递归地构造左子树，并连接到根节点
        // 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
        root->left = myBuildTree(preorder, inorder, preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1);
        // 递归地构造右子树，并连接到根节点
        // 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
        root->right = myBuildTree(preorder, inorder, preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right);
        return root;
    }

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int n = preorder.size();
        // 构造哈希映射，帮助我们快速定位根节点
        for (int i = 0; i < n; ++i) {
            index[inorder[i]] = i;
        }
        return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1);
    }
};

> 作者：LeetCode-Solution
> 链接：https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/solution/cong-qian-xu-yu-zhong-xu-bian-li-xu-lie-gou-zao-9/ 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

//一、二步同上
//其实第三步原理是一样的，不过我们的脑子习惯了从前到后，所以，让我帮你们转个弯。

//像对中序分割一样，将后序序列也分割了。
//从中序排列的分割中我们知道根节点的右子树有哪些成员，所以后序序列这样分：
//（H I D J K E B）（L F G C）
//现在就很明显可以看出根节点左子树的“根节点”是谁了吧

//重复以上步骤

class Solution {
private:
    unordered_map<int, int> index;

public:
    TreeNode* myBuildTree(const vector<int>& lastorder, const vector<int>& inorder, int lastorder_left, int lastorder_right, int inorder_left, int inorder_right) {
        if (lastorder_left > lastorder_right) {
            return nullptr;
        }
        
        // 后序遍历中的最后一个节点就是根节点
        int lastorder_root = lastorder_right;
        // 在中序遍历中定位根节点
        int inorder_root = index[lastorder[lastorder_root]];
        
        // 先把根节点建立出来
        TreeNode* root = new TreeNode(lastorder[lastorder_root]);
        // 得到左子树中的节点数目
        int size_left_subtree = inorder_root - inorder_left;
        // 递归地构造左子树，并连接到根节点
        // 后序遍历中「从 左边界开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
        root->left = myBuildTree(lastorder, inorder, lastorder_left, lastorder_left + size_left_subtree-1, inorder_left, inorder_root - 1);
        // 递归地构造右子树，并连接到根节点
        // 后序遍历中「从 左边界+左子树节点数目 开始到 右边界-1 」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
        root->right = myBuildTree(lastorder, inorder, lastorder_left + size_left_subtree, lastorder_right-1, inorder_root + 1, inorder_right);
        return root;
    }

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int n = preorder.size();
        // 构造哈希映射，帮助我们快速定位根节点
        for (int i = 0; i < n; ++i) {
            index[inorder[i]] = i;
        }
        return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1);
    }
};

1.创建队列，存储每一层的结点；
2.使用循环从队列中弹出一个结点：
 2.1获取当前结点的key；
 2.2如果当前结点的左子结点不为空，则把左子结点放入到队列中
 2.3如果当前结点的右子结点不为空，则把右子结点放入到队列中

#include<queue>
#include<iostream>

using namespace std;

void LevelOrder(Node *root) {
	if (root == NULL)
		return;
		
	queue<Node *>	q;
	// 启动
	q.push(root);

	while (!q.empty()) {
		Node *front = q.front();
		q.pop();

		cout<<front->value;

		if (front->left != NULL) 
			q.push(front->left);

		if (front->right != NULL) 
			q.push(front->right);
	}
	cout<<endl;
}

#include<vector>
#include<iostream>

using namespace std;

class SerchTree{
private:
	TreeNode* root;
public:
	SerchTree();

	//插入节点
	void Insert_Node(TreeNode* root,int val){
		if(NULL == root)
			root = new TreeNode(val);
		else{
			if(val<root->val)
				Insert_Node(root->left,val);
			else{	//一样大就往左走吧
				Insert_Node(root->right,val);
			}
		}
	}

	//从数组中构造二叉搜索树	
	void Create_SerchTree(vector<int>& vec){
		int sz = vec.size();
		for(int i = 0;i<sz;i++){
			Insert_Node(root,vec[i]);
		}
	}

	//搜索某个节点是否存在
	bool SerchNode(TreeNode* root,int val){
		if(NULL == root)
			return false;
		if(val<root->val)
			return SerchNode(root->left,val);
		else if(val>root->val)
			return SerchNode(root->right)
		else
			return ture;
	}
	
	//删除节点
	void DelNode(TreeNode* node){
		TreeNode* temp;
		if(NULL == node->right){	//如果右子节点为空
			temp = node;
			node = node->left;
			delete temp;
		}
		else{	//如果右子节点不空
			temp = node;
			while(NULL != temp->left){
				temp = temp->left;
			}
			node->val = temp->val;
			delete temp;
		}
	}	
	//删除某个节点
	void DelSerchNode(TreeNode* root,int val){
		if(NULL == root)
			return;
		if(val<root->val)
			return DelSerchNode(root->left,val);
		else if(val>root->val)
			return DelSerchNode(root->right)
		else
			DelNode(root);
	}

	//计算二叉树的最大深度
	int maxDepth(Node x) { 	//1.如果根结点为空，则最大深度为0； 
		if (x == null) 
			return 0; 
		
		int max = 0; 
		int maxL = 0; 
		int maxR = 0; 
	
		//2.计算左子树的最大深度； 
		if (x.left != null)  
			maxL = maxDepth(x.left); 
			
		//3.计算右子树的最大深度； 
		if (x.right != null)
			maxR = maxDepth(x.right);
			 
		//4.当前树的最大深度=左子树的最大深度和右子树的最大深度中的较大者+1 
		max = maxL > maxR ? maxL + 1 : maxR + 1; return max; 
	}
}

    class AVLNode
    {
    private:
        int depth; //深度，这里计算每个结点的深度，通过深度的比较可得出是否平衡
        Tree parent; //该结点的父节点，方便操作
        int val; //结点值
        TreeNode lchild;
        TreeNode rchild;
        
    public:
        AVLNode(int val=0)
        {
            parent=NULL;
            depth=0;
            lchild=rchild=NULL;
            this->val=val;
        }
    };

（1）节点的右孩子替代此节点位置
（2）右孩子的左子树变为该节点的右子树
（3）节点本身变为右孩子的左子树

（1）节点的左孩子代表此节点
（2）节点的左孩子的右子树变为节点的左子树
（3）将此节点作为左孩子节点的右子树。

AVLNode rightRotate(AVLNode y){
	AVLNode x = y.lchild;	//即将返回的节点是y的左子节点
	AVLNode t3 = x.rchild;	//先把y的右子节点取出来
	x.rchild = y;			//把y放进x的右子节点
	y.lchild = t3;			//把前面预存的放到y的左子节点
	//更新height
	y.height = Math.max(getHeight(y.lchild),getHeight(y.rchild))+1;
	x.height = Math.max(getHeight(x.lchild),getHeight(x.rchild))+1;
	return x;
}

AVLNode leftRotate(AVLNode y){
	AVLNode x = y.rchild;
	NAVLNode ode t2 = x.lchild;
	x.lchild= y;
	y.rchild= t2;
	//更新height
	y.height = Math.max(getHeight(y.lchild),getHeight(y.rchild))+1;
	x.height = Math.max(getHeight(x.lchild),getHeight(x.rchild))+1;
	return x;
}

AVLNode add(AVLNode node, int val){
	if(node == null){
		size ++;
		return new AVLNode(val);
	}
	if(val.compareTo(node.val) < 0)
		node.lchild = add(node.lchild, val);
	else if(val.compareTo(node.val) > 0)
		node.rchild = add(node.rchild, val);
	//更新height
	node.height = 1+Math.max(getHeight(node.lchild),getHeight(node.rchild));
	//计算平衡因子
	int balanceFactor = getBalanceFactor(node);
	if(balanceFactor > 1 && getBalanceFactor(node.lchild)>0) {
		//右旋LL
		return rightRotate(node);
	}
	if(balanceFactor < -1 && getBalanceFactor(node.rchild)<0) {
		//左旋RR
		return leftRotate(node);
	}
	//LR
	if(balanceFactor > 1 && getBalanceFactor(node.lchild) < 0){
		node.lchild = leftRotate(node.lchild);
		return rightRotate(node);
	}
	//RL
	if(balanceFactor < -1 && getBalanceFactor(node.rchild) > 0){
		node.rchild = rightRotate(node.rchild);
		return leftRotate(node);
	}
	return node;
}

int getBalanceFactor(AVLNode node){
	if(node==NULL){
		return 0;
	}
	return getHeight(node.lchild)-getHeight(node.rchild);
}

int getHeight(AVLNode node){
	if(node==NULL){
		return 0;
	}
	return node.height;
}

//compareTo方法：
返回值是整型，它是先比较对应字符的大小(ASCII码顺序)，如果第一个字符和参数的第一个字符不等，结束比较，返回他们之间的差值，如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推,直至比较的字符或被比较的字符有一方结束。

    如果参数字符串等于此字符串，则返回值 0；
    如果此字符串小于字符串参数，则返回一个小于 0 的值；
    如果此字符串大于字符串参数，则返回一个大于 0 的值。

int remove(int e){
	AVLNode node = getNode(root, e);
	if(node != NULL){
		root = remove(root, e);
		return node.e;
	}
	return NULL;
}

AVLNode remove(AVLNode node, int e){
	if( node == NULL )
		return NULL;
	AVLNode retNode;
	if( e.compareTo(node.e) < 0 ){
		node.left = remove(node.left , e);
		retNode = node;
	}
	else if(e.compareTo(node.e) > 0 ){
		node.right = remove(node.right, e);
		retNode = node;
	}
	else{   // e.compareTo(node.e) == 0
		// 待删除节点左子树为空的情况
		if(node.left == NULL){
			Node rightNode = node.right;
			node.right = NULL;
			size --;
			retNode = rightNode;
		}
		// 待删除节点右子树为空的情况
		else if(node.right == NULL){
			Node leftNode = node.left;
			node.left = NULL;
			size --;
			retNode = leftNode;
		}else {
			// 待删除节点左右子树均不为空的情况
			// 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
			// 用这个节点顶替待删除节点的位置
			Node successor = minimum(node.right);
			successor.right = remove(node.right, successor.e);
			successor.left = node.left;

			node.left = node.right = NULL;

			retNode = successor;
		}
	}
	if(retNode==NULL)
		return NULL;
	//维护平衡
	//更新height
	retNode.height = 1+Math.max(getHeight(retNode.left),getHeight(retNode.right));
	//计算平衡因子
	int balanceFactor = getBalanceFactor(retNode);
	if(balanceFactor > 1 && getBalanceFactor(retNode.left)>=0) {
		//右旋LL
		return rightRotate(retNode);
	}
	if(balanceFactor < -1 && getBalanceFactor(retNode.right)<=0) {
		//左旋RR
		return leftRotate(retNode);
	}
	//LR
	if(balanceFactor > 1 && getBalanceFactor(retNode.left) < 0){
		node.left = leftRotate(retNode.left);
		return rightRotate(retNode);
	}
	//RL
	if(balanceFactor < -1 && getBalanceFactor(retNode.right) > 0){
		node.right = rightRotate(retNode.right);
		return leftRotate(retNode);
	}
	return retNode;
}

typedef bool __rb_tree_color_type;
const __rb_tree_color_type __rbtree_red = false;	//红0
const __rb_tree_color_type __rbtree_black = true;	//黑1

struct __rb_tree_node_base
{
	typedef __rb_tree_color_type color_type;
	typedef __rb_tree_node_base* base_ptr;
	color_type color;
	base_ptr parent;
	base_ptr left;
	base_ptr right;

	static base_ptr minimum(base_ptr x)
	{ ··· }
	static base_ptr maximum(base_ptr x)
	{ ··· }
}

template <class Value>
struct __rb_tree_node :public __rb_tree_node_base
{
	typedef ____rb_tree_node<Value>* link_type;
	Value value_field;	//节点值
} 

template<class Key,class Value,class KeyOfValue,class Compare,class Alloc = alloc>
class rb_tree
{
protected:
	typedef void* void_pointer;
	typedef __rb_tree_node<Value> rb_tree_node;
	typedef	__rb_tree_node* base_ptr;
	typedef simple_alloc<rb_tree_node,Alloc> rb_tree_node_allocator;
	typedef __rb_tree_color_type color_type;

public:
	typedef Key key_type;
	typedef Value value_type;
	typedef value_type* pointer;
	typedef const value_type* const_pointer;
	typedef value_type& reference;
	typedef rb_tree_node* link_node;
	typedef size_t size_type;
	typedef	ptrdiff_t difference_type;

protected:
	···		
	link_type header;	//这是实现上的一个技巧
	Compare key_compare;	//节点间的键值大小比较准则
	
	//以下三个函数用于取得header的成员
	link_type& root() const { return (link_type&)header->parent; }
	link_type& leftmost() const { return (link_type&)header->left; }
	link_type& rightmost() const { return (link_type&)header->right; }

	···
	
};

//返回的是一个RB-tree迭代器，指向新增节点

template<class Key,class Value,class KeyOfValue,class Compare,class Alloc>
typename rb_tree<Key,Value,KeyOfValue,Compare,Alloc>::iterator		//	这一行是返回值类型
rb_tree<Key,Value,KeyOfValue,Compare,Alloc>::insert_equal(const Value& v)	//这句看不懂的话我还有另一篇博客专门讲解这种句法，只是代码块里面放不了链接
{
	link_type y = header;
	link_type x = root();

	while(x!=0)
	{
		y = x;
		x = key_compare(KeyOfValue()(v),key(x)) ? left(x) : right(x);	//左右转
	}
	return __insert(x,y,v);	//x:新值插入点  y:插入点之父节点  v:新值
}

template<class Key,class Value,class KeyOfValue,class Compare,class Alloc>
pair<typename rb_tree<Key,Value,KeyOfValue,Compare,Alloc>::iterator>		//	这一行是返回值类型
rb_tree<Key,Value,KeyOfValue,Compare,Alloc>::insert_unique(const Value& v)
{
	link_type y = header;
	link_type x = root();

	bool comp = true;
	while( x != 0 )
	{
		y = x;
		comp = key_compare(KeyOfValue()(v),key(x));
		 x = comp ? left(x) : right(x);	//左右转
	}
	//循环转出来之后，y所指的便是插入节点的父节点，此时y必为叶节点
	iterator j = iterator(y);	//令迭代器j指向插入y
	if(comp)	//y节点值大于新值
		if(j == begin())	//如果插入点的父节点为最左	
			return pair<iterator,bool>(__insert(x,y,v),true);
		else
			--j;	//调整j,回头准备测试（我也不知道要测试啥）
	if(key_compare(key(j.node)KeyOfValue(key())(v))	//y节点小于新值
		return pair<iterator,bool>(__insert(x,y,v),true);

return pair<iterator,bool>(j,false);//要是走到这一步，那说明键值重复了
}

template<class Key,class Value,class KeyOfValue,class Compare,class Alloc>
typename rb_tree<Key,Value,KeyOfValue,Compare,Alloc>::iterator		//	这一行是返回值类型
rb_tree<Key,Value,KeyOfValue,Compare,Alloc>::__insert(base_ptr x_,base_ptr y_,const Value& v)	
{
	link_type y = link_type y_;
	link_type x = link_type x_;
	link_type z;

	if(y == header || x!=0 || Key_compare(KeyOfValue()(v),key(y)))
	{
		z = create_node(v);	//产生一个新节点
		left(y) = z;
		if(y == header)
		{
			root() = z;
			rightmost() = z;
		}
		else if(y == leftmost())
			leftmost() = z;
	}
	else
	{
		z = create_node(v);
		right(y) = z;
		if(y == rightmost())
			rightmost() = z;
	}
	parent(z) = y;	//设定新节点的父节点
	left(z) = 0;
	right(z) = 0;

	__rb_tree_rebalalance(z,header->parent);
	++node_count;
	return iterator(z);	//返回一个迭代器，指向新节点
	
}

//函数功能：重新令树型平衡

inline void __rb_tree_rebalance(__rb_tree_node_base* x/* 新增节点*/,__rb_tree_node_base*& root)
{
	x->color = __rb_tree_red;
	while( x != root && x->parent->color == __rb_tree_red)	//父节点为红
	{
		if( x->parent == x->parent->parent->left )	//父节点为祖父节点的左子节点
		{
			__rb_tree_node_base* y = x->parent->parent->right;	//将y作为它的伯父节点
			if( y && y->color == __rb_tree_red)	//如果真的有伯父节点，且为红
			{
				x->parent->color = __rb_tree_black;	//将父节点改黑
				y->color = __rb_tree_black;	//将伯父也抹黑
				y->parent->color = __rb_tree_red;	//把爷爷放红
				x = x->parent->parent;	//自己当爷爷							
			}
			else	//没有伯父，或者伯父是非洲回来的
			{
				if( x == x->parent->right)	//如果新节点为父节点右孩子
				{
					x = x->parent;	//自己当爸爸
					__rb_tree_rotate_left(x,root);	//第一参数为左旋点
				}
				x->parent->color = __rb_tree_black;	//将父节点抹黑
				x->parent->parent->color = __rb_tree_red;	//把爷爷放红
				__rb_tree_rotate_right(x->parent->parent,root);	//第一参数为右旋点	
			}
		}	
		else	//父节点为祖父节点右子节点
		{
			__rb_tree_node_base* y = x->parent->parent->left;	//令y为伯父节点
			if( y && y->color == __rb_tree_red)	//如果真的有伯父节点，且为红
			{
				x->parent->color = __rb_tree_black;	//将父节点改黑
				y->color = __rb_tree_black;	//将伯父也抹黑
				y->parent->color = __rb_tree_red;	//把爷爷放红
				x = x->parent->parent;	//自己当爷爷							
			}
			else	//没有伯父，或者伯父是非洲回来的
			{
				if( x == x->parent->left)	//如果新节点为父节点左孩子
				{
					x = x->parent;	//自己当爸爸
					__rb_tree_rotate_right(x,root);	//第一参数为左旋点
				}
				x->parent->color = __rb_tree_black;	//将父节点抹黑
				x->parent->parent->color = __rb_tree_red;	//把爷爷放红
				__rb_tree_rotate_right(x->parent->parent,root);	//第一参数为右旋点	
			}
		}
	}	//while结束
	root->color = __rb_tree_black;	//根节点抹黑
}

//左旋

inline void __rb_tree_rotate_left(__rb_tree_node_base* x,__rb_tree_node_base*& root)
{
	__rb_tree_node_base* y = x->right;	//令y为旋转点的右子节点
	x->right = y->left;	//令旋转点的右子节点的左子节点为旋转点的右节点
	if(y->left != 0)
		y->left->parent = x;	//并不知道这个有什么意义
	y->parent = x->parent;

	//令y完全顶替x的位置
	if(x == root)
		root = y;
	else if(x == x->parent->left)
		x->parent->left = y;
	else
		x->parent->right = y;
	y->left = x;
	x->parent = y;
}

//右旋

inline void __rb_tree_rotate_right(__rb_tree_node_base* x,__rb_tree_node_base*& root)
{
	__rb_tree_node_base* y = x->left;	//令y为旋转点的左子节点
	x->left = y->right;	//令旋转点的右子节点的左子节点为旋转点的右节点
	if(y->right != 0)
		y->right->parent = x;	//并不知道这个有什么意义
	y->parent = x->parent;

	//令y完全顶替x的位置
	if(x == root)
		root = y;
	else if(x == x->parent->right)
		x->parent->right = y;
	else
		x->parent->left = y;
	y->right = x;
	x->parent = y;
}

根据给定的n个权值{W1,W2,...,Wn}构成n棵二叉的集合F={T1,T2,...Tn}，其中每棵二叉树Ti只有一个带权为Wi的根结点，其左右子树均为空。
在F中选取2棵根结点最小的树 作为左右子树 构造一棵新的二叉树，且新的二叉树的根结点左右子树根结点权值之和。
在F中删除这2棵子树，同时将新得到的二叉树加入F中。
重复2和3步骤，直到F只含一棵树为止，这棵树便是哈夫曼树。

//.h

#pragma once 
#ifndef __HUFFMANTREE_H__
#define __HUFFMANTREE_H__
 
//创建哈夫曼树提供的字符的最大长度
#define MAX_SZ 256
//哈夫曼编码字符串最大长度
#define MAX_ENCODE 1024
//哈夫曼树结点数据结构
typedef struct HuffmanNode
{
	char data;
	struct HuffmanNode *lchild, *rchild;
}HuffmanNode,*HuffmanTree;
 
//哈夫曼编码表结点数据结构
typedef struct HuffmanTableNode
{
	char data;		//字符
	char *encode;	//字符对应的哈夫曼编码
	struct HuffmanTableNode *next;
}HuffmanTableNode;
//哈夫曼编码表数据结构
typedef struct HuffmanTable
{
	HuffmanTableNode* front;//指向队头元素
	HuffmanTableNode* tail;	//指向队尾元素
}HuffmanTable;
 
//根据用户提供原始数据，生成对应的哈夫曼树
HuffmanTree BuildHuffmanTree(char* inputString);
 
//根据哈夫曼树 生成对应的哈夫曼编码表
HuffmanTable* BuildHuffmanTable(HuffmanTree tree);
 
//对用户提供的源字符进行哈夫曼编码
char* encode(HuffmanTable* table, char* src);
 
//根据用户提供的哈夫曼编码进行解码
char* decode(HuffmanTree root, char* encode);
 
//遍历哈夫曼编码表
void TraverseHuffmanTable(HuffmanTable* table);
#endif // !__HUFFMANTREE_H__

//.cpp

#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "HuffmanTree.h"
#include "HuffQueue.h"
 
//根据用户提供字符集，生成对应的哈夫曼树
HuffmanTree BuildHuffmanTree(char* inputString)
{
	//统计每个字符出现的权值
	int charWeight[MAX_SZ] = { 0 };
	for (int i = 0; i < inputString[i]!=''; i++)
	{
		charWeight[(unsigned char)inputString[i]]++;
	}
	HuffQueue* queue = NULL;
	InitHuffQueue(&queue);
 
	for (int i = 0; i <MAX_SZ; i++)
	{
		//对应的字符有权值，创建树结点，添加到树节点队列中
		if (charWeight[i])
		{
			HuffmanNode* treeNode = (HuffmanNode*)malloc(sizeof(HuffmanNode));
			treeNode->data = i;
			treeNode->lchild = treeNode->rchild = NULL;
			AddHuffQueueNode(queue, treeNode, charWeight[i]);
		}
	}
	//根据哈夫曼树创建原理构建哈夫曼树
	//核心就是将权值最小的2个结点，取出作为新创建树结点的孩子结点，新创建树结点的权值为它们之和，然后放回树结点队列
	//一直这样循环进行操作，直到队列中最后剩一个结点，它就是树的根结点。
	while (queue->size != 1)
	{
		HuffQueueNode* node1 = GetHuffQueueNode(queue);
		HuffQueueNode* node2 = GetHuffQueueNode(queue);
		HuffmanNode* treeNode = (HuffmanNode*)malloc(sizeof(HuffmanNode));
		treeNode->data = '';
		treeNode->lchild = node1->treeNode;
		treeNode->rchild = node2->treeNode;
		int weightNum = node1->weightNum + node2->weightNum;
		AddHuffQueueNode(queue, treeNode, weightNum);
	}
	return queue->first->treeNode;
}
/*
递归遍历哈夫曼树
depth 树的深度
tree 哈夫曼树
hTable 哈夫曼编码表
encode 字符对应的哈夫曼编码
*/
void traverseHuffTree(HuffmanTable* hTable,HuffmanTree tree,char* encode,int depth)
{
	
	if (NULL == tree->lchild && NULL == tree->rchild)
	{
		HuffmanTableNode* tableNode = (HuffmanTableNode*)malloc(sizeof(HuffmanTableNode));
		tableNode->data = tree->data;
		tableNode->next = NULL;
		encode[depth] = '';
		tableNode->encode = (char*)malloc(depth+1);
		strcpy(tableNode->encode, encode);
		if (hTable->front == NULL)
		{
			hTable->front = hTable->tail = tableNode;
		}
		else
		{
			hTable->tail->next = tableNode;
			hTable->tail = tableNode;
		}
	}
	if (NULL != tree->lchild)
	{
		encode[depth] = '0';//左分支代表0
		traverseHuffTree(hTable, tree->lchild, encode, depth+1);
	}
 
	if (NULL != tree->rchild)
	{
		encode[depth] = '1';//右分支代表1
		traverseHuffTree(hTable, tree->rchild, encode, depth+1);
	}
	return;
}
 
//根据哈夫曼树生成哈夫曼编码表
HuffmanTable * BuildHuffmanTable(HuffmanTree tree)
{
	HuffmanTable* hTable = (HuffmanTable*)malloc(sizeof(HuffmanTable));
	hTable->front = hTable->tail = NULL;
	char encode[MAX_SZ] = { 0 };
	traverseHuffTree(hTable, tree, encode, 0);
	return hTable;
}
 
//对用户提供的源字符进行哈夫曼编码
char* encode(HuffmanTable* table,char* src)
{
	char* encode = (char*)calloc(sizeof(char)*MAX_ENCODE,1);
	for (int i = 0; i < src[i]!=''; i++)
	{
		char ch = src[i];
		HuffmanTableNode* iterator = table->front;
		while (iterator != NULL)
		{
			if (iterator->data == ch)
			{
				strcat(encode, iterator->encode);
				break;
			}
			iterator = iterator->next;
		}
		if (iterator == NULL)
		{
			printf("哈夫曼编码表中没有字符%c对应的哈夫曼编码！n",ch);
			return NULL;
		}
	}
	return encode;
}
 
//根据用户提供的哈夫曼编码进行解码
char* decode(HuffmanTree root,char* encode)
{
	char* decode = (char*)calloc(MAX_SZ, 1);
	HuffmanTree tree = root;
	for (int i = 0; i < encode[i]!=''; i++)
	{
		char ch = encode[i];
		if ('0' == ch)//0 往左走
		{
			tree = tree->lchild;
		}
		else//1 往右走
		{
			tree = tree->rchild;
		}
		//走到头，也就是找到相应的 源字符了
		if (tree->lchild == NULL && tree->rchild == NULL)
		{
			strncat(decode, &tree->data, 1);
			//找到字符后，树节点回到根结点，继续解码
			tree = root;
		}
	}
	return decode;
}
 
//打印哈夫曼编码表
void TraverseHuffmanTable(HuffmanTable* table)
{
	HuffmanTableNode* node = table->front;
	while (node != NULL)
	{
		printf("源字符:%c ->哈夫曼编码:%sn", node->data, node->encode);
		node = node->next;
	}
}
 
int main(int argc, char *argv[])
{
	HuffmanTree tree = BuildHuffmanTree("aabbccc");
	HuffmanTable* table = BuildHuffmanTable(tree);
	TraverseHuffmanTable(table);
	char *src = "abc";
	char* dest = "10110101101";
	char* encode_str = encode(table, src);
	char* decode_str = decode(tree, dest);
	printf("原始字符串:%s ->哈夫曼编码:%sn", src, encode_str);
	printf("哈夫曼编码:%s ->解码为:%sn", dest, decode_str);
	return 0;
}