已知先序和中序构建二叉树并且以层序输出

题目描述

   深度遍历一棵二叉树有先序，中序和后序三种方式，并且根据遍历序列能确定一棵二叉树，要唯一确定一棵二叉树至少需要两种遍历序列 先序+中序 或 后序+中序，（先序+后序无法唯一确定） 现在给定你一棵二叉树的先序和中序序列，请你构造出这棵二叉树，并且输出其层序遍历结果

输入

输入包含多组测试数据

对每组测试数据:

第一行为一个正整数n（0<n<=100）代表二叉树节点个数

第二行为这棵树的先序遍历序列

第三行为其中序遍历序列

（每个节点为整型数字）

当读到文件结尾时输入结束.

输出

对每组测试数据

在一行中输出这棵树的层序遍历结果 中间用空格隔开，最后一个数字后面不得有空格。

样例输入

8
7 10 4 3 1 2 8 11
4 10 3 1 7 11 8 2

样例输出

7 10 2 4 3 8 1 11

：

#include <iostream>
#include <queue>
using namespace std;

typedef struct Node
{
int data;
struct Node* LChild;
struct Node* RChild;
}Node;

//种树
Node* ConstructCore(int* startPreorder, int* endPreorder, int* startInorder, int* endInorder)
{
int rootValue  = startPreorder[0];
Node* root = new Node;
root->data = rootValue;
root->LChild = root->RChild = NULL;
if (startPreorder == endPreorder)
{
if (startInorder == endInorder && *startPreorder == *endInorder)
return root;
}
int* rootInorder = startInorder;
while (rootInorder <= endInorder && *rootInorder != rootValue)
rootInorder++;
int leftLength = rootInorder - startInorder;
int* leftPreorderEnd = startPreorder + leftLength;

if (leftLength > 0)
{
root->LChild = ConstructCore(startPreorder + 1, leftPreorderEnd, startInorder, rootInorder - 1);
}//左子树

if(leftLength < endPreorder - startPreorder)
{
root->RChild = ConstructCore(leftPreorderEnd + 1, endPreorder, rootInorder + 1, endInorder);
}//右子树

return root;
}

Node* Construct(int* preorder, int* inorder, int length)
{
if (preorder == NULL || inorder == NULL || length <= 0)
return NULL;

return ConstructCore(preorder, preorder + length - 1, inorder, inorder + length - 1);
}

//倒序输出
void TraverseTreePostorder(Node* proot)
{
if(proot == NULL)
return;

if(proot->LChild != NULL)
TraverseTreePostorder(proot->LChild);
if(proot->RChild != NULL)
TraverseTreePostorder(proot->RChild);

cout << proot->data << " ";
}

//层序输出
void Print(Node* T) {
int parentSize = 1, childSize = 0;
queue <Node*> q;
Node* temp;
q.push(T);
temp = q.front();
cout << temp->data << " ";
while (!q.empty())
{
q.pop();
if (temp->LChild != NULL)
{
q.push(temp->LChild);
childSize++;
}
if (temp->RChild != NULL)
{
q.push(temp->RChild);
childSize++;
}
parentSize--;
if (parentSize == 0)
{
parentSize = childSize;
childSize = 0;
}
if (!q.empty())
{
temp = q.front();
cout << temp->data << " "; //控制输出格式
}
}

}
int main()
{
int n, i;
while (scanf("%d", &n) != EOF)
{
int preorder[100];
int inorder[100];

for (i = 0; i < n; i++)
cin >> preorder[i];
for (i = 0; i < n; i++)
cin >> inorder[i];

Node* pRoot = Construct(preorder, inorder, n);

//		TraverseTreePostorder(pRoot);
//		cout << endl;   //倒序输出
Print(pRoot);
}
return 0;
}