线索二叉树

BiTree.h

#include <vector>
#include <iostream>
using namespace std;
enum BiThrNodeType{LINK,THREAD};
template <class T>
struct BiNode
{
	BiThrNodeType ltype,rtype;
	T data;
	BiNode<T> *lchild;
	BiNode<T> *rchild;
};
static BiNode<char> *preNode=NULL;
template <class T>
class BiTree
{
private:
	BiNode<T> *root;
	BiNode<T> *CreateByPre(vector<T>&pre,int &i)
	{
		T e = pre[i];
		i++;
		if(e=='*')
			return NULL;
		BiNode <T> *p = new BiNode<T>;
		p->data = e;
		p->ltype=LINK;
		p->rtype=LINK;
		p->lchild = CreateByPre(pre,i);
		p->rchild = CreateByPre(pre,i);
		return p;
	}
	void PreOrder(BiNode<T> *p)
	{
		if(p==NULL)
			return;
		cout<<p->data<<" ";
		PreOrder(p->lchild);
		PreOrder(p->rchild);
	}
	void MidOrder(BiNode<T> *p)
	{
		if(p==NULL)
			return;
		
		PreOrder(p->lchild);
		cout<<p->data<<" ";
		PreOrder(p->rchild);
	}
	void AftOrder(BiNode<T> *p)
	{
		if(p==NULL)
			return;
		PreOrder(p->lchild);
		PreOrder(p->rchild);
		cout<<p->data<<" ";
	}
	BiTree<T> *CreateByPreMid(vector<T> &pre,vector<T> &mid,int ipre,int imid,int n)
	{
		if(n==0)
			return NULL;
		BiNode<T> *p = new BiNode<T>;
		p->data = pre[ipre];
		for(i=0;i<n;i++)
		{
			if(pre[ipre]==mid[imid+i])
				break;
		}
		p->lchild=CreateByPreMid(pre,mid,ipre+1,imid,i);
		p->rchild=CreateByPreMid(pre,mid,ipre+i+1,imid+i+1,n-i-1);
		return p;
	}
	BiTree<T> *Copy(BiNode<T> *p)
	{
		if(p==NULL)
			return NULL;
		BiNode<T> *newp = new BiNode<T>;
		newp->data = p->data;
		newp->lchild = Copy(p->lchild);
		newp->rchild = Copy(p->rchild);
		return newp;
	}
	int Count(BiNode<T> *p)
	{
		if(p==NULL)
			return 0;
		int left=Count(p->lchild);
		int right=Count(p->rchild);
		return 1+left+right;
	}
	int Count0(BiNode<T> *p)
	{
		if(p==NULL)
			return 0;
		return (p->lchild==NULL&&p->rchild==NULL)+Count0(p->lchild)+Count0(p->rchild);
	}
	int Count2(BiNode<T> *p)
	{
		if(p==NULL)
			return 0;
		return (p->lchild!=NULL&&p->rchild!=NULL)+Count2(p->lchild)+Count2(p->rchild);
	}
	int Count1(BiNode<T> *p)
	{
		if(p==NULL)
			return 0;
		return ((p->lchild==NULL&&p->rchild!=NULL)||(p->lchild!=NULL&&p->rchild==NULL))+Count1(p->lchild)+Count1(p->rchild);
	}
	int High(BiNode<T> *p)
	{
		if(p==NULL)
			return 0;
		return High(p->lchild)>High(p->rchild)?1+High(p->lchild):1+High(p->rchild);
	}
	BiNode<T> * Search(BiNode<T>*p , T &e)
	{
		if(p==NULL)
			return NULL;
		if(p->data==e)
			return p;
		BiNode<T> *q=Search(p->lchild,e);
		if(q!=NULL)
			return q;
		return Search(p->rchild,e);
	}
	BiNode<T> *SearchParent(BiNode<T> *p,BiNode<T> *child)
	{
		if(p==NULL)
			return NULL;
		if(p->lchild==child||p->rchild==child)
			return p;
		BiNode<T> *q = SearchParent(p->lchild,child);
		if(q)
			return q;
		return SearchParent(p->rchild,child);
	}
	void InThreaded(BiNode<T> *p)
	{
		if(p==NULL)
			return;
		InThreaded(p->lchild);
		if(p->lchild==NULL)
		{
			p->ltype=THREAD;
			p->lchild=preNode;
		}
		if(p->rchild==NULL)
			p->rtype=THREAD;
		if(preNode!=NULL)
		{
			if(preNode->rtype==THREAD)
			{
				preNode->rchild=p;
			}
		}
		preNode=p;
		InThreaded(p->rchild);
	}
public:
	void InThreaded()
	{
		InThreaded(root);
	}
	int Count0()
	{
		return Count0(root);
	}
	int Count2()
	{
		return Count2(root);
	}
	int Count1()
	{
		return Count1(root);
	}
	int High()
	{
		return High(root);
	}
	int Count()
	{
		return Count(root);
	}
	BiTree()
	{
		root = NULL;
	}
	BiTree(BiTree<T> &tree)
	{
		root=Copy(tree.root);
	}
	BiTree(vector<T> &pre)
	{
		int i=0;
		root = CreateByPre(pre,i);
	}
	BiTree(vector<T> &pre,vector<T> &mid)
	{
		n=pre.size();
		root = CreateByPreMid(pre,mid,0,0,n);
	}
	void PreOrder()
	{
		PreOrder(root);
	}
	void MidOrder()
	{
		MidOrder(root);
	}	
	void AftOrder()
	{
		AftOrder(root);
	}
	BiNode<T> *SearchParent(BiNode<T> *child)
	{
		return SearchParent(root,child);
	}
	BiNode<T> *Search(T &e)
	{
		return Search(root,e);
	}
	BiNode<T> *GetNext(BiNode<T> *p)
	{
		if(p->rtype==THREAD)
			return p->rchild;
		p=p->rchild;
		while(p->ltype==LINK)
			p=p->lchild;
		return p;
	}
	BiNode<T> *GetBefore(BiNode<T> *p)
	{
		if(p->ltype==THREAD)
			return p->lchild;
		p=p->lchild;
		while(p->rtype==LINK)
			p=p->rchild;
		return p;
	}
	void Travese()
	{
		BiNode<T> *p=root;
		while(p->ltype==LINK)
			p=p->lchild;
		while(p!=NULL)
		{
			cout<<p->data<<" ";
			p=GetNext(p);
		}
	}
	BiNode<T> *GetParent(BiNode<T> *p)
	{
		if(p==NULL)
			return NULL;
		BiNode<T> *parent;
		parent=p;
		while(parent->rtype==LINK)
			parent=parent->rchild;
		parent=parent->rchild;
		if(parent&&parent->lchild==p)
			return parent;	
		parent = p;
		while(parent->ltype==LINK)
			parent=parent->lchild;
		return parent;
	}
};

main.cpp

#include<iostream>
#include"BiTree.h"
using namespace std;
int main()
{
	vector<char> M;
	M.push_back('1');
	M.push_back('2');
	M.push_back('3');
	M.push_back('*');
	M.push_back('*');
	M.push_back('4');
	M.push_back('*');
	M.push_back('*');
	M.push_back('5');
	M.push_back('6');
	M.push_back('*');
	M.push_back('*');
	M.push_back('*');

	BiTree<char> TREE(M);
	TREE.InThreaded();
	TREE.Travese();

	return 0;
}