南邮 OJ 1021 二叉树复制和左右子树互换

二叉树复制和左右子树互换

时间限制(普通/Java) :  1000 MS/ 3000 MS          运行内存限制 : 65536 KByte
总提交 : 387            测试通过 : 251 

比赛描述

二叉树是非常重要的树形数据结构。复制一棵二叉树是在另一个存储区存放相同的结构和内容，而一棵二叉树上所有左右子树互换是在原存储区上的运算。

 

请分别根据先序遍历序列建立两棵的二叉树（用#代表空树或空子树），再将这两棵二叉树复制为左右子树建立第三棵二叉树，输出先序和层次遍历序列，最后将第三棵二叉树上所有左右子树互换，并输出先序和层次遍历序列。

输入

共三行

前两行分别对应两棵二叉树的先序遍历序列，用#代表空树或空子树

第三行为第三棵二叉树的根结点。

输出

共四行

前两行为第三棵二叉树生成时的先序、层次遍历序列，

后两行为第三棵二叉树左右子树互换后的先序、层次遍历序列。

样例输入

B # D # #
C E # # F # #
A

样例输出

PreOrder: A B D C E F
LevelOrder: A B C D E F
PreOrder: A C F E B D
LevelOrder: A C B F E D

题目来源

CHENZ

#include <iostream>
#include <cassert>
#define MAX(a,b) (a>b?a:b)
using namespace std;

template<typename Type>
class QueueNode{
public:
	Type data;
	QueueNode *next;
};

template<typename Type>
class Queue{
public:
	QueueNode<Type> *Head;			//指向第一个元素，方便出队
	QueueNode<Type> *Tail;			//指向最后一个元素，方便插入

	void PushBack(const Type&);
	Type PopFront(void);
};

/*
*函数功能：队尾加入新元素
*入口参数：const Type& data：将要插入的元素
*出口参数：无
*作者：陈汝军
*时间：2014-8-19 20:17:13
*/
template<typename Type>
void Queue<Type>::PushBack(const Type& data){
	if(Head == NULL){
		Head = new QueueNode<Type>();
		Head->data = data;
		Tail = Head;
	}else{
		Tail->next = new QueueNode<Type>();
		Tail->next->data = data;
		Tail = Tail->next;	
	}
}
/*
*函数功能：队首弹出元素
*入口参数：无
*出口参数：Type PopFront：弹出的元素
*作者：陈汝军
*时间：2014-8-19 20:18:08
*/ 
template<typename Type>
Type Queue<Type>::PopFront(void){
	QueueNode<Type> *TempHead = Head;
	Type TempData = Head->data;
	assert(Head!=NULL);
	Head = Head->next;
	delete TempHead;
	return TempData;
}


template<typename Type>
class BTNode{
public:
	Type data;
	BTNode *lChild;
	BTNode *rChild;

	void PreOrder(void);
	void InOrder(void);
	void PostOrder(void);
	static void PreOrderInput(BTNode<Type>* &Head);		//静态成员函数，调用与具体的类无关
	int  Height(void);
	int  NodeNum(void);
	int  LeafNum(void);
	void TransLevel(void);
	void Exchange(void);
};

/*
*函数功能：先序遍历二叉树。
*入口参数：this.
*出口参数：无
*作者：陈汝军
*时间：2014-8-18 22:01:59
*/
template<typename Type>
void BTNode<Type>::PreOrder(){
	if(this == NULL)
		return;
	cout<<" "<<this->data;
	this->lChild->PreOrder();
	this->rChild->PreOrder();
}
/*
*函数功能：中序遍历二叉树。
*入口参数：this.
*出口参数：无
*作者：陈汝军
*时间：2014-8-18 22:03:36
*/
template<typename Type>
void BTNode<Type>::InOrder(){
	if(this == NULL)
		return;
	this->lChild->InOrder();
	cout<<" "<<this->data;
	this->rChild->InOrder();	
}
/*
*函数功能：后序遍历二叉树。
*入口参数：this.
*出口参数：无
*作者：陈汝军
*时间：2014-8-18 22:04:09
*/
template<typename Type>
void BTNode<Type>::PostOrder(){
	if(this == NULL)
		return;
	this->lChild->PostOrder();
	this->rChild->PostOrder();
	cout<<" "<<this->data;
}
/*
*函数功能：先序输入二叉树，用#代表空树或空子树。
*入口参数：BTNode* &Head：树的节点指针的引用
*出口参数：无
*作者：陈汝军
*时间：2014-8-18 22:01:59
*/
template<typename Type>
void BTNode<Type>::PreOrderInput(BTNode* &Head){
	Type data;
	cin>>data;
	if(data == '#'){
		Head = NULL;	
	}else{
		Head = new BTNode<Type>();
		Head->data = data;
		BTNode<char>::PreOrderInput(Head->lChild);
		BTNode<char>::PreOrderInput(Head->rChild);	
	}
}
/*
*函数功能：输出二叉树的高度
*入口参数：this：本节点指针
*出口参数：Height：高度
*作者：陈汝军
*时间：2014-8-19 10:21:03
*/
template<typename Type>
int BTNode<Type>::Height(void){
	if(this == NULL){
		return 0;
	}else{
		return MAX(this->lChild->Height(),this->rChild->Height())+1;
	}
}
/*
*函数功能：求二叉树的总结点数
*入口参数：this：本节点指针
*出口参数：NodeNum：以本节点为树根的总节点数
*作者：陈汝军
*时间：2014-8-19 10:24:16
*/
template<typename Type>
int BTNode<Type>::NodeNum(void){
	if(this == NULL){
		return 0;
	}else{
		return this->lChild->NodeNum()+this->rChild->NodeNum()+1;
	}	
}
/*
*函数功能：求二叉树的叶节点数
*入口参数：this：本节点指针
*出口参数：LeafNum：以本节点为树根的叶节点数
*作者：陈汝军
*时间：2014-8-19 10:29:36
*/
template<typename Type>
int BTNode<Type>::LeafNum(void){
	if(this==NULL){
		return 0;
	}else if(this->lChild==NULL && this->rChild==NULL){
		return 1;
	}else{
		return this->lChild->LeafNum()+this->rChild->LeafNum();
	}	
}
/*
*函数功能：层次遍历二叉树
*入口参数：无
*出口参数：无
*作者：陈汝军
*时间：2014-8-19 20:48:29
*/
template<typename Type>
void BTNode<Type>::TransLevel(void){
	Queue<BTNode<Type>*> *que = new Queue<BTNode<Type>*>();
	if(this == NULL)
		return;
	que->PushBack(this);
	while(que->Head!=NULL){					//输出整个队列，输出过程中队列在增长
		if(que->Head->data->lChild!=NULL){
			que->PushBack(que->Head->data->lChild);
		}
		if(que->Head->data->rChild!=NULL){
			que->PushBack(que->Head->data->rChild);
		}
		cout<<" "<<que->PopFront()->data;
	}
}
template<typename Type>
void BTNode<Type>::Exchange(void){
	BTNode<Type> *Temp;
	if(this == NULL){
		return;
	}
	if(this->lChild!=NULL || this->rChild!=NULL){
		Temp = this->lChild;
		this->lChild = this->rChild;
		this->rChild = Temp;
	}
	this->lChild->Exchange();
	this->rChild->Exchange();
}
int main(void){
	BTNode<char> *Head=NULL,*Left=NULL,*Right=NULL;
	BTNode<char>::PreOrderInput(Left);
	BTNode<char>::PreOrderInput(Right);
	Head = new BTNode<char>();
	cin>>Head->data;
	Head->lChild = Left;
	Head->rChild = Right;
	cout<<"PreOrder:";
	Head->PreOrder();
	cout<<endl<<"LevelOrder:";
	Head->TransLevel();
	Head->Exchange();
	cout<<endl<<"PreOrder:";
	Head->PreOrder();
	cout<<endl<<"LevelOrder:";
	Head->TransLevel();
	return 0;
}