题目:输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6},则重建出二叉树并输出它的头结点。
代码没有重新写,是15年秋数据结构的OJ题,徒手写的队列和二叉树的类。
#include <iostream>
using namespace std;
/***********************************Queue******************************/
template<class T>
struct LinkNode
{
T data;
LinkNode<T> *next;
LinkNode(LinkNode<T> *top = NULL)
{
next = top;
}
LinkNode(T elem,LinkNode<T> *top = NULL)
{
data = elem;
next = top;
}
};
template<class T>
class Queue
{
private:
LinkNode<T> *first,*rear;
public:
Queue()
{
rear = first = new LinkNode<T>;
}
~Queue()
{
makeEmpty();
}
bool EnQueue(const T& elem)
{
LinkNode<T>* newNode = new LinkNode<T>(elem);
if(!newNode)
return false;
if(IsEmpty())
first->next = rear = newNode;
rear->next=newNode;
rear=rear->next;
return true;
}
bool DeQueue(T& elem)
{
LinkNode<T>* del;
if(first==rear)
return false;
del=first->next;
elem=del->data;
first->next=del->next;
if(first->next==NULL)
rear=first;
delete del;
return true;
}
bool IsEmpty()
{
return (first == rear)? true:false;
}
void makeEmpty()
{
LinkNode<T> *p = first->next;
if(!p)
return;
while(first->next)
{
first = p->next;
delete p;
p = first->next;
}
}
};
/*********************************BinaryTree***************************/
template<class T>
struct BinTreeNode
{
T data;
BinTreeNode<T> *lchild, *rchild;
BinTreeNode()
{
lchild = NULL;
rchild = NULL;
}
BinTreeNode(T x, BinTreeNode<T>* l = NULL, BinTreeNode<T>* r = NULL)
{
data = x;
lchild = l;
rchild = r;
}
};
template<class T>
class BinaryTree
{
private:
BinTreeNode<T>* root;
void destroy(BinTreeNode<T>* root)
{
if(root)
{
destroy(root->lchild);
destroy(root->rchild);
delete root;
}
}
public:
BinaryTree()
{
root = NULL;
}
BinaryTree(BinTreeNode<T>* p)
{
root = p;
}
BinaryTree(T *elems, int n) ///构造函数,层序输入,建立满二叉树
{
root = new BinTreeNode<T> [n];
for(int i=0; i<n; i++)
{
root[i].data=elems[i];
if(2*i+1<n)
{
root[i].lchild=&root[2*i+1];
}
else
{
root[i].lchild=NULL;
}
if(2*i+2<n)
{
root[i].rchild=&root[2*i+2];
}
else
{
root[i].rchild=NULL;
}
}
}
BinaryTree(BinaryTree<T>& a);
~BinaryTree()
{
}
BinTreeNode<T> *visitRoot()
{
return root;
}
bool isEmpty()
{
return (root == NULL)?true:false;
}
BinTreeNode<T> *Parent(BinTreeNode<T>* current)
{
return (root == NULL || root == current)?NULL:Parent(root,current);
}
BinTreeNode<T> *LeftChild(BinTreeNode<T>* current)
{
return (current != NULL)?current->lchild:NULL;
}
BinTreeNode<T> *RightChild(BinTreeNode<T>* current)
{
return (current != NULL)?current->rightChild:NULL;
}
void PreOrder(BinTreeNode<T>* p = visitRoot()) ///递归前序遍历
{
if(p)
{
cout << p->data << " ";
PreOrder(p->lchild);
PreOrder(p->rchild);
}
}
void InOrder(BinTreeNode<T>* p = visitRoot()) ///递归中序遍历
{
if(p)
{
InOrder(p->lchild);
cout << p->data << " ";
InOrder(p->rchild);
}
}
void PostOrder(BinTreeNode<T>* p = visitRoot()) ///递归后序遍历
{
if(p)
{
PostOrder(p->lchild);
PostOrder(p->rchild);
cout << p->data << " ";
}
}
void LevelOrder(BinTreeNode<T>* p) ///非递归层序遍历
{
Queue<BinTreeNode<T>*> q;
BinTreeNode<T>* pre = root;
q.EnQueue(pre);
cout << pre->data << " ";
while(!q.IsEmpty())
{
q.DeQueue(pre);
if(pre->lchild != NULL)
{
q.EnQueue(pre->lchild);
cout << pre->lchild->data << " ";
}
if(pre->rchild != NULL)
{
q.EnQueue(pre->rchild);
cout << pre->rchild->data << " ";
}
}
}
};
template <class T>
BinTreeNode<T> *CreateBinTree(T* VLR, T* LVR, int n) ///根据前序和中序递归重建二叉树
{
if(n == 0)
return NULL;
int k = 0;
while(VLR[0] != LVR[k])
k++;
BinTreeNode<T> *t = new BinTreeNode<T>(VLR[0]);
t->lchild = CreateBinTree(VLR+1,LVR,k);
t->rchild = CreateBinTree(VLR+k+1,LVR+k+1,n-k-1);
return t;
}
int main()
{
int n = 8;
int a[8] = {1,2,4,7,3,5,6,8}; ///前序序列
int b[8] = {4,7,2,1,5,3,8,6}; ///中序序列
BinTreeNode<int> *p = CreateBinTree(a,b,n);
BinaryTree<int> tree(p);
tree.LevelOrder(p); ///层序输出
cout << endl;
tree.PostOrder(p); ///后序输出
return 0;
}