树

#include <iostream>
using namespace std;
typedef char elemtype;
struct TNode   //树中结点采用孩子兄弟表示法
{
	elemtype data;
	TNode *firstchild, *rightsib;
};

class Tree
{
public:
	Tree( );               //构造函数，初始化一棵树，其前序序列由键盘输入
	~Tree(void);           //析构函数，释放树中各结点的存储空间
	TNode * Getroot( );  //获得指向根结点的指针
	void PreOrder(TNode *root);     //前序遍历树
	void PostOrder(TNode *root);    //后序遍历树
	void LeverOrder(TNode *root);   //层序遍历树
private:
	TNode *root;         //指向根结点的头指针
	void Release(TNode *root);   //析构函数调用 
};
Tree::Tree( )
{
	const int MaxSize = 100;
    int end = 0;
	int front = 0;
	int rear  = 0;  //采用顺序队列，并假定不会发生上溢
	int j = 0;	
	TNode* queue[MaxSize]; //声明一个队列 
	TNode* tempNode;              //声明指向结点类型的指针  
	TNode* brotherNode;   //工作指针
    TNode* q;
	elemtype ch;
    cout<<"请输入创建一棵树的根结点数据"<<endl;
	cin>>ch;
    root = new TNode;
	root->data = ch;
	root->firstchild = NULL;
	root->rightsib = NULL;
    queue[rear++] = root;  
    while (!end)    //若继续创建树
	{ 
		elemtype ch1,ch2;
		cout<<"请输入创建一棵树的父结点数据和孩子结点数据"<<endl;
		cin>>ch1>>ch2;
		TNode* p = new TNode;       //生成一个结点
		p->data = ch2;
		p->firstchild = NULL;    
		p->rightsib = NULL; 
        queue[rear++] = p;
		tempNode = queue[front];//头结点出队，同时对头元素的标识符后移           			
		while(ch1 != tempNode->data)  		
			tempNode = queue[front++];											
		if(tempNode->firstchild == NULL)	tempNode->firstchild = p;
		else{
			brotherNode = tempNode->firstchild;  //工作指针指向结点的第一个孩子
			while (brotherNode != NULL)          //若第一个孩子有兄弟结点
			{
				q = brotherNode;
				brotherNode = brotherNode->rightsib;//工作指针指向第一个孩子的右兄弟				
			}            
			q->rightsib = p;			        
		}
		cout<<"创建结束? 如果结束请按1否则请按0 "<<endl;
		cin>>end;
	}
}
/*
 *前置条件：树已存在
 *输    入：无
 *功    能：释放树中各结点的存储空间
 *输    出：无
 *后置条件：树不存在 
 */
Tree::~Tree(void)
{
	Release(root);
}
/*
 *前置条件：树已存在
 *输    入：无
 *功    能：获取指向树根结点的指针
 *输    出：指向树根结点的指针
 *后置条件：树不变 
 */

TNode* Tree::Getroot( )
{
	return root;
}
/*
 *前置条件：树已存在
 *输    入：无
 *功    能：前序遍历树
 *输    出：树中结点的一个线性排列
 *后置条件：树不变 
 */

void Tree::PreOrder(TNode *root)      //前序遍历树
{
	if (root == NULL)  return;     //递归调用的结束条件
	else{		
		cout<<root->data;          //打印根节点
		PreOrder(root->firstchild);    //前序递归遍历root的第一个孩子
		PreOrder(root->rightsib);    //前序递归遍历root的右兄弟  
	}
}
/*
 *前置条件：树已存在
 *输    入：无
 *功    能：后序遍历树
 *输    出：树中结点的一个线性排列
 *后置条件：树不变 
 */

void Tree::PostOrder(TNode *root)
{ 
	if (root == NULL)  return;     //递归调用的结束条件
	else{		
		PostOrder(root->firstchild);    //后序递归遍历root的第一个孩子
        cout<<root->data;               //打印出root结点
		PostOrder(root->rightsib);      //后序递归遍历root的右兄弟        
	}
} 
/*
 *前置条件：树已存在
 *输    入：无
 *功    能：层序遍历树
 *输    出：树中结点的一个线性排列
 *后置条件：树不变
 */
void Tree::LeverOrder(TNode *root)   
{		
	const int MAX_QUEUE_SIZE = 100;
	int front = 0;
	int rear  = 0;  //采用顺序队列，并假定不会发生上溢		
	TNode* queue[MAX_QUEUE_SIZE]; //声明一个队列 
	TNode* tempNode;      //声明指向结点类型的指针  
	TNode* brotherNode;   //工作指针

	if (root == NULL) return;//循环结束条件
	queue[rear++] = root;    //否则结点入队
	while (front != rear)    //若队列中有结点
	{
		tempNode = queue[front++];//头结点出队，同时对头元素的标识符后移
		cout<<tempNode->data;     //打印出头结点    
		brotherNode = tempNode->firstchild;  //工作指针指向结点的第一个孩子
		while (brotherNode != NULL)          //若第一个孩子有兄弟结点
		{
			queue[rear++] = brotherNode;     //第一个孩子结点入队
			brotherNode = brotherNode->rightsib;//工作指针指向第一个孩子的右兄弟
		}
	}
}
/*
 *前置条件：树已经存在
 *输    入：无
 *功    能：释放树的存储空间，析构函数调用
 *输    出：无
 *后置条件：树不存在
 */

void Tree::Release(TNode* root)
{
	if (root != NULL){ 	
		Release (root->firstchild);   //释放第一个孩子
		Release (root->rightsib);   //释放右兄弟
        delete root;
	}
}

void main() 
{
	Tree t; //创建一棵树
	TNode* p = t.Getroot( );  //获取指向根结点的指针 
	cout<<"------前序遍历------ "<<endl;
	t.PreOrder(p);
	cout<<endl;
	cout<<"------后序遍历------ "<<endl;
	t.PostOrder(p);
	cout<<endl;
	cout<<"------层序遍历------ "<<endl;
	t.LeverOrder(p);
	cout<<endl;
}