树

//btree.h

#ifndef BTREE_H_H
#define BTREE_H_H

#include 
using namespace std;

template 
class Tree;

template
class TreeNode
{
	friend class Tree;
private:
	TreeNode * firstChild;
	TreeNode * nextSibling;

public:
	T data;
	TreeNode(T value, TreeNode * fc = NULL, TreeNode * ns = NULL):data(value),firstChild(fc),nextSibling(ns){}
	TreeNode * &FirstChild(void){return firstChild;}
	TreeNode * &NextSibling(void){return nextSibling;}
};

template
class Tree
{
private:
	TreeNode * root;
	TreeNode * current;
	
public:
	Tree(){root = current = NULL;}
	~Tree(){DeleteSubTree(root);}

	int Current(TreeNode * &t);
	int Root();
	int Parent();
	int FirstChild();
	int NextSibling();

	void InsertChild(T value);
	void DeleteSubTree(TreeNode * &t);
	int DeleteChild(int i);
	TreeNode * SearchParent(TreeNode * &root, TreeNode * &s);

	void PreOrderTree(TreeNode * &t);
	void MidOrderTree(TreeNode * &t);
	void PostOrderTree(TreeNode * &t);
	
	void DisplayTree();
};

#endif
//btree.cpp

#include "btree.h"

template
int Tree::Current(TreeNode * &t)
{
	if(t == NULL)
	{
		return 0;
	}
	else
	{
		current = t;
		return 1;
	}
}

template
int Tree::Root()
{
	if(root == NULL)
	{
		current = NULL;
		return  0;
	}
	return Current(root);
}

template
int Tree::Parent()
{
	if(current == NULL)
	{
		current = root;
		return 0;
	}
	TreeNode * p = SearchParent(root,current);
	if(p==NULL)
		return 0;
	else
		return Current(p);
}

template
int Tree::NextSibling()
{
	if(current != NULL && current->nextSibling != NULL)
		return Current(current->nextSibling);
	else
		return 0;
}

template
int Tree::FirstChild()
{
	if(current != NULL && current->firstChild != NULL)
		return Current(current->firstChild);
	else
		return 0;
}

template
void Tree::InsertChild(T value)
{
	TreeNode * newNode = new TreeNode(value);
	if(root==NULL)
	{
		root = current = newNode;
        return;
	}
	if(current->firstChild == NULL)
		current->firstChild = newNode;
	else
	{
		TreeNode * p = current->firstChild;
		while(p->nextSibling != NULL)
			p = p->nextSibling;
		p->nextSibling = newNode;
	}
	Current(newNode);
}

template
void Tree::DeleteSubTree(TreeNode * &t)
{
	if(t == NULL) return;
	TreeNode * q = t->firstChild, * p;
	while(q != NULL)
	{
		p = q->nextSibling;
		DeleteSubTree(q);
		q = p;
	}
	coutfirstChild;
		if(r == NULL)
			return 0;  
		current->firstChild = r->nextSibling; 
	}
	else
	{
		int k = 1;
		TreeNode * p = current->firstChild;
		while(p != NULL && k <= i-1)
		{
			p = p->nextSibling;
			k++;
		}
		if(p != NULL) 
		{
			r = p->nextSibling;
			if(r != NULL)
				p->nextSibling = r->nextSibling;
			else 
				return 0; 
		}
		else
			return 0; 
	}
	DeleteSubTree(r); 
	return   1;
}

template
TreeNode * Tree::SearchParent(TreeNode * &root, TreeNode * &s)
{
	if(root == NULL) 
		return NULL;
	if(root->FirstChild() == s || root->NextSibling() == s)
		return root;
	TreeNode * ptr;
	if((ptr = SearchParent(root->FirstChild(),s)) != NULL)
		return ptr;
	if((ptr = SearchParent(root->NextSibling(),s)) != NULL)
		return ptr;
	return NULL;
}

template
void Tree::PreOrderTree(TreeNode * &t)
{
	if(t == NULL)
	   return;
	coutfirstChild != NULL)
		PreOrderTree(t->firstChild);
	if(t->nextSibling != NULL)
		PreOrderTree(t->nextSibling);
}

template
void Tree::MidOrderTree(TreeNode * &t)
{
	if(t==NULL)
		return;
    if(t->firstChild != NULL)
		PostOrderTree(t->firstChild);
	coutnextSibling != NULL)
		PostOrderTree(t->nextSibling);
}

template
void Tree::PostOrderTree(TreeNode * &t)
{
	if(t==NULL)
		return;
    if(t->firstChild != NULL)
		PostOrderTree(t->firstChild);
	if(t->nextSibling != NULL)
		PostOrderTree(t->nextSibling);
	coutInsertChild(i);
		tree->Root();
	}

	tree->DisplayTree();

	return 0;
}