二叉树插件操作，改天来注释，要多用引用和++i，不然stl用起来很慢，总是被构造和析构，切记

# include <malloc.h>
# include <iostream>
# include <conio.h>
# include <stdlib.h>
#include <string>
#include <queue>
#include <assert.h>
using namespace std;
# define OK 1
# define ERROR 0	
# define OVERFLOW 0
typedef char TElemType;
static string prostr,instr,postdtr;
static int m;
typedef struct BiTNode			//定义二叉树结构
{  
	TElemType		data;
struct BiTNode	*lchild,*rchild;
}BiTNode, *BiTree;

int PostOrderTraverse(BiTree T)		//PreOrderTravers sub-function
{  
	if(T)
	{  
		if (PostOrderTraverse(T->lchild))
		{
			if (PostOrderTraverse(T->rchild))
			{cout<<T->data<<"->";					//visite T
			postdtr +=T->data;
			return OK;}
		}
		return (ERROR);
	} //if end
	else
		return (OK);
} //PreOrderTraverse() end
void TInOrder(BiTree T)		//中序 sub-function
{  
	BiTNode *tstack[100];
	BiTNode *p = T;
	int top =0;
	do 
	{
		while (p)
		{
			top++;
			tstack[top] = p;
			p = p->lchild;
		}
		if (top>0)
		{
			p = tstack[top];
			cout<<p->data;
			top--;
// 			if (p->rchild)
// 			{
// 				top++;
// 				tstack[top] = p->rchild;
// 			}
			p =p->rchild;//一直取到p的度为2的节点
		}
	} while (p!=NULL||top!=0);
	
} //PreOrderTraverse() end
void TPostOrder(BiTree T)		//后序 sub-function
{  
	BiTNode *tstack[100];
	BiTNode *p = T;
	int top =0;
	int tag[100];
	do 
	{
		while (p)
		{		
			tag[top] =0;
			tstack[top] = p;
			p = p->lchild;
			top++;
		}
		if (top>0){
			while (tag[top-1]==1)//如果堆栈顶的tag为1，那么
			{
				top--;
				p = tstack[top];
				cout<<p->data;
			}
			if(top>0)
			{
				tag[top-1] = 1;//将它置为1的目的是看看tstack[top-1]这个节点有
				//没有右节点，如果有的话，就保存到tstack[top-1]之前
				p = tstack[top-1];
				p = p->rchild;
			}
		}
	} while (top>0);

}
void TPreOrder(BiTree T)		//PreOrderTravers sub-function
{  
	BiTNode *tstack[100];
	BiTNode *p = T;
	int top =0;
	while (p->lchild&&p->rchild)
	{
		top =1;
		tstack[top] = T;
		while (top>0)
		{
			p= tstack[top];
			cout<<p->data;
			top--;
			if (p->rchild)
			{
				tstack[++top] = p->rchild;
			}
			if (p->lchild)
			{
				top++;
				tstack[top] = p->lchild;
			}
		}
	}
} //PreOrderTraverse() end

// string TProcess(string prostr, string instr)		//PreOrderTravers sub-function
// {  
// 	string ch="";
// 	ch+=postdtr[0];
// 	string npre1="",npre2="",nmid1="",nmid2="";
// 	int i,j;
// 	int len1 = postdtr.length();
// 	int len2 = instr.length();
// 	if (len1==1||len1==0)
// 	{
// 		return postdtr;
// 	}
// 	i=instr.find(ch);                    //查找pre[0]在mid中的位置 
// 	nmid1=instr.substr(0,i);              //求nmid1 
// 	nmid2=instr.substr(i+1);               //求nmid2 
// 	npre1=prostr.substr(1,i);              //求npre1 
// 	npre2=prostr.substr(i+1);              //求npre2 
// 	return TProcess(npre1,nmid1)+TProcess(npre2,nmid2)+ch;   //rear=nrear1+nrear2+pre[0
// } 


void exchange(BiTree T)
{
	if (T == NULL)
	{
		return ;
	}
	//assert(T);
	if (NULL ==T->lchild && NULL == T->rchild)
	{
		return ;
	}
	BiTNode *p = (BiTNode *)malloc(sizeof(BiTNode));
//	p->data = T->lchild->data;
	p->lchild = T->lchild;
	T->lchild = T->rchild;
	T->rchild = p->lchild;
	//free p;
	//p = NULL;
	exchange(T->lchild);
	exchange(T->rchild);
}

//判断一个节点t是否在以r为根的子树中
bool is_in_tree(BiTNode *r, BiTNode *t)
{
	if(r == NULL)
	{
		return false;
	}
	else if(r->data == t->data)
	{
		return true;
	}
	else
	{
		bool has = false;
		if(r->lchild != NULL)
		{
			has = is_in_tree(r->lchild,t);
		}
		if(!has && r->rchild!= NULL)
		{
			has = is_in_tree(r->rchild,t);
		}
		return has;
	}
 }


BiTNode * get_nearest_common_father(BiTNode *r,BiTNode *pNode1,BiTNode *pNode2)
{
	//pNode2在以pNode1为根的子树中（每次递归都要判断，放在这里不是很好。）
	if(is_in_tree(pNode1,pNode2))
	{
		return pNode1;
	}
	//pNode1在以pNode2为根的子树中
	if(is_in_tree(pNode2,pNode1))
	{
		return pNode2;
	}
	bool one_in_left,one_in_right,another_in_left,another_in_right;
	one_in_left = is_in_tree(r->lchild,pNode1);
	another_in_right = is_in_tree(r->rchild,pNode2);
	another_in_left = is_in_tree(r->lchild,pNode2);
	one_in_right = is_in_tree(r->rchild,pNode1);
	if((one_in_left && another_in_right) || (one_in_right && another_in_left))
	{
		return r;
	}
	else if(one_in_left && another_in_left)
	{
		return get_nearest_common_father(r->lchild,pNode1,pNode2);
	}
	else if(one_in_right && another_in_right)
	{
		return get_nearest_common_father(r->rchild,pNode1,pNode2);
	}
	else
	{
		return NULL;
	}
 }


//层次遍历
int BFS (BiTree T)
{
	if (T == NULL)
	{
		return 0;
	}
	deque<BiTNode *> q;//使用队列
	q.push_back(T);
	while (!q.empty())
	{
		BiTNode * p = q.front();
		cout<<p->data<<" -- ";
		q.pop_front();
		if (p->lchild != NULL)
		{
			q.push_back(p->lchild);
		}
		if (p->rchild != NULL)
		{
			q.push_back(p->rchild);
		}
	}
	cout<<endl;
	return 1;
	
}

void main()			//main() 函数
{  
	BiTree T;

	int Depth_BT (BiTree T);		//声明函数
	int CreateBiTree(BiTree &T);	
	int PreOrderTraverse(BiTree T);
	int InOrderTraverse(BiTree T);
	cout<<"下面以'根左右'的顺序构造二叉树: \n\n";
	cout<<"请输入二叉树元素,(/表示空),如 ABDG///EH//IK///C/F/J//"<<endl;
	if(CreateBiTree(T))			//调用 CreateBiTree()
	{
		cout<<"\n\n构造二叉树成功 ! 先序('根左右')遍历新建的二叉树如下:\n ";
		PreOrderTraverse(T);
		cout<<"NULL";
	}
	else
	cout<<endl<<"构造二叉树失败 ! ";
	cout<<endl;
	//exchange(T);
	BiTNode * node1 = (BiTNode *)malloc(sizeof(BiTNode));
 	node1->data = 'H';
	BiTNode * node2 = (BiTNode *)malloc(sizeof(BiTNode));
	BiTNode * node3 = (BiTNode *)malloc(sizeof(BiTNode));
 	node1 = T->lchild->lchild->lchild;
	node2 = T->lchild->rchild->rchild;
// 	bool findt = is_in_tree(T, node1);
	node3 = get_nearest_common_father(T,node1, node2);
	if (node3 != NULL)
	{
		cout<<node3->data<<endl;
	}
	InOrderTraverse(T);
	cout<<endl;
	//if (findt)
	{
		cout<<"HHHHHHHHHHHHHH"<<endl;
	}
	
	PostOrderTraverse(T);

	cout<<"\n\n二叉树的深度是 "<<Depth_BT(T)<<" !";	//调用Depth_BT()
	cout<<"\n\n...OK!..."<<endl;
	cout<<"haha"<<endl;
	TPreOrder(T);
	cout<<endl<<"heihei"<<endl;
	TInOrder(T);
		cout<<endl<<"yaya"<<endl;
	TPostOrder(T);
	// 	cout<<instr<<endl;
	// 	KPreOrderTraverse(T, 4);
	// 	
} //main() end

void KPreOrderTraverse(BiTree T, int k)		//PreOrderTravers sub-function
{  
	if(T&&k!=0)
	{  
		cout<<T->data<<"->";					//visite T
		//prostr+=T->data;
		m = k-1;//开全局变量，来存储现在已经找到几个节点
		KPreOrderTraverse(T->lchild,m);
		KPreOrderTraverse(T->rchild,m);

	} //if end

} //PreOrderTraverse() end
int CreateBiTree(BiTree &T)			//createBiTree() 子函数
{  
	TElemType ch;	
	cin>>ch;
	if(ch=='/')  
		T=NULL;
	else
	{  
		if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))
			exit(OVERFLOW);
		T->data=ch;
		CreateBiTree(T->lchild);	//create lchild
		CreateBiTree(T->rchild);	//create rchild
	}
	return (OK);
} //CreateBiTree() end

int PreOrderTraverse(BiTree T)		//PreOrderTravers sub-function
{  
	if(T)
	{  
		cout<<T->data<<"->";					//visite T
		prostr+=T->data;
		if (PreOrderTraverse(T->lchild))		//traverse lchild
			if (PreOrderTraverse(T->rchild))	//traverse rchild
				return (OK);
		return (ERROR);
	} //if end
	else
		return (OK);
} //PreOrderTraverse() end


int InOrderTraverse(BiTree T)		//PreOrderTravers sub-function
{  
	if(T)
	{  
		if (InOrderTraverse(T->lchild))
		{
			cout<<T->data<<"->";					//visite T
			instr +=T->data;
			if (InOrderTraverse(T->rchild))
			return OK;
		}
		return (ERROR);
	} //if end
	else
		return (OK);
} //PreOrderTraverse() end
int Depth_BT ( BiTree T )		// T 采用二叉链表存储结构，求二叉树 T 的深度
{
	int d,depth_r,depth_l;
	if ( !T )		// 如果是空树，则其深度为 0
		return ( 0 );
	else  
	{
		depth_l = Depth_BT ( T->lchild );	// 递归调用 Depth_BT 算法，求二叉树 T 的左子树的深度
		depth_r = Depth_BT ( T->rchild );	// 递归调用 Depth_BT 算法，求二叉树 T 的右子树的深度
		if ( depth_l >= depth_r )	// 如果左子树的深度大于等于右子树的深度，则取左子树的深度为树 T 的深度
			d = depth_l;
		else						// 否则取右子树的深度为树 T 的深度
			d = depth_r;
		return ( 1+d );				//返回值
	} // else 结束
} // Depth_BT