//输入前序和中序得到整棵树,并进行前中后序遍历以及层序遍历
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1000+5;
struct BinaryTreeNode{
int T_Value;
BinaryTreeNode* T_Left;
BinaryTreeNode* T_Right;
};
struct Node{
BinaryTreeNode* TreeNode;
int len;
};
//递归建树
BinaryTreeNode* ConstructCore(BinaryTreeNode* PreRoot,int flag,int* startPre,int* endPre,int* startIn,int* endIn)
{
int rootValue = startPre[0];
BinaryTreeNode* root = new BinaryTreeNode();
root->T_Value = rootValue;
root->T_Left = root->T_Right = nullptr;
if(flag==1&&PreRoot!=nullptr) {
PreRoot->T_Left = root;
}
else if(flag==0&&PreRoot!=nullptr) {
PreRoot->T_Right = root;
}
//如果只剩下一个根节点
if(startPre==endPre&&startIn==endIn&&*startPre==*endPre&&*startIn==*endIn&&*startPre==*endIn)
{
return root;
}
//在中序遍历中找到这个根节点
int* rootNode = startIn;
while(rootNode<endIn&&*rootNode!=rootValue)
{
rootNode++;
}
if(rootNode==endIn&&*rootNode!=rootValue)
{
printf("the input is wrong!!!\n");
return root;
}
//递归构建左右子树
int LeftLength = rootNode - startIn;
int RightLength = endIn - rootNode;
int* RightPreStart = startPre+LeftLength+1;
if(LeftLength>0)
{
ConstructCore(root,1,startPre+1,startPre+LeftLength,startIn,rootNode-1);
}
if(RightLength>0)
{
ConstructCore(root,0,RightPreStart,endPre,rootNode+1,endIn);
}
return root;
}
BinaryTreeNode* Construct(int* Pre,int* In,int length)
{
if(Pre==nullptr||In==nullptr||length<=0) return nullptr;
return ConstructCore(nullptr,-1,Pre,Pre+length-1,In,In+length-1);
}
//前序遍历
void dfsPreOrder(BinaryTreeNode* root,int deep)
{
if(root==nullptr) {
return;
}
printf("%d %d\n",root->T_Value,deep);
dfsPreOrder(root->T_Left,deep+1);
dfsPreOrder(root->T_Right,deep+1);
}
//中序遍历
void dfsInOrder(BinaryTreeNode* root,int deep)
{
if(root==nullptr) {
return;
}
dfsInOrder(root->T_Left,deep+1);
printf("%d %d\n",root->T_Value,deep);
dfsInOrder(root->T_Right,deep+1);
}
//后序遍历
void dfsLastOrder(BinaryTreeNode* root,int deep)
{
if(root==nullptr) {
return;
}
dfsLastOrder(root->T_Left,deep+1);
dfsLastOrder(root->T_Right,deep+1);
printf("%d %d\n",root->T_Value,deep);
}
//层序遍历 bfs
void bfsTree(BinaryTreeNode* root,int deep)
{
queue<Node>pq;
while(!pq.empty()) pq.pop();
Node now ;
now.TreeNode = root;
now.len = deep;
pq.push(now);
while(!pq.empty())
{
Node node = pq.front();
pq.pop();
printf("%d %d\n",node.TreeNode->T_Value,node.len);
if(node.TreeNode->T_Left!=nullptr) {
now.len = node.len+1;
now.TreeNode = node.TreeNode->T_Left;
pq.push(now);
}
if(node.TreeNode->T_Right!=nullptr) {
now.len = node.len+1;
now.TreeNode = node.TreeNode->T_Right;
pq.push(now);
}
}
}
int main()
{
int n;
scanf("%d",&n);
int Pre[maxn],In[maxn];
for(int i = 0;i<n;i++)
{
scanf("%d",&Pre[i]);
}
for(int i = 0;i< n;i++)
{
scanf("%d",&In[i]);
}
BinaryTreeNode* root = Construct(Pre,In,n);
printf("树的前序遍历及各节点高度:\n");
dfsPreOrder(root,1);
printf("树的中序遍历及各节点高度:\n");
dfsInOrder(root,1);
printf("树的后序遍历及各节点高度:\n");
dfsLastOrder(root,1);
printf("树的层序遍历及各节点高度:\n");
bfsTree(root,1);
return 0;
}
#include<bits/stdc++.h>
using namespace std;
//构建二叉树 并进行二叉树的前序遍历 中序遍历 后序遍历 层序遍历.
const int maxn = 100+5;
struct TreeNode{
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x):val(x),left(nullptr),right(nullptr){}
TreeNode():val(),left(nullptr),right(nullptr){}
};
class Solution{
public:
Solution()
{
}
~Solution()
{
}
//前序遍历
void PreOrder(TreeNode* root,vector<int>& vec)
{
if(root==nullptr) return;
vec.push_back(root->val);
PreOrder(root->left,vec);
PreOrder(root->right,vec);
}
//中序遍历
void InOrder(TreeNode* root,vector<int>& vec)
{
if(root==nullptr) return;
InOrder(root->left,vec);
vec.push_back(root->val);
InOrder(root->right,vec);
}
//后序遍历
void AfterOrder(TreeNode* root,vector<int>& vec)
{
if(root==nullptr) return;
AfterOrder(root->left,vec);
AfterOrder(root->right,vec);
vec.push_back(root->val);
}
//层序遍历
void bfsOrder(TreeNode* root,vector<int>& vec)
{
if(root==nullptr) return;
queue<TreeNode*>pq;
while(!pq.empty()) pq.pop();
pq.push(root);
while(!pq.empty())
{
TreeNode* now = pq.front();
pq.pop();
vec.push_back(now->val);
if(now->left!=nullptr) {
pq.push(now->left);
}
if(now->right!=nullptr) {
pq.push(now->right);
}
}
}
bool BfsCom_Bin_Tree(TreeNode* root)
{
if(root==nullptr) return false;
queue<TreeNode*> pq;
while(!pq.empty()) pq.pop();
pq.push(root);
bool flag = false;
while(!pq.empty())
{
TreeNode* now = pq.front();
pq.pop();
if(flag) {
if(now->left!=nullptr||now->right!=nullptr) return false;
}
if(now->left!=nullptr) {
if(now->right==nullptr) {
flag =true;
pq.push(now->left);
}
else {
pq.push(now->left);
pq.push(now->right);
}
}
else {
if(now->right==nullptr) {
flag = true;
}
else {
return false;
}
}
}
return true;
}
// 判断是否是完全二叉树
//使用层序遍历,如果当前节点只有右节点,那么一定不是完全二叉树,否则,如果当前节点只有左节点或者无节点,那么这个节点后面的所有节点均为叶子节点
bool Complete_Binary_Tree(TreeNode* root)
{
if(root==nullptr) return false;
return BfsCom_Bin_Tree(root);
}
bool BfsFull_Bin_Tree(TreeNode* root)
{
if(root==nullptr) return false;
bool flag = false;
int deep = 1;
queue<pair<TreeNode*,int> > pq;
while(!pq.empty()) pq.pop();
pq.push(make_pair(root,1));
while(!pq.empty())
{
pair<TreeNode*,int>node;
node = pq.front();
pq.pop();
if(flag) {
if(deep<node.second) return false;
}
if((node.first->left!=nullptr&&node.first->right==nullptr)||(node.first->left==nullptr&&node.first->right!=nullptr)) return false;
if(node.first->left==nullptr&&node.first->right==nullptr) {
flag = true; //表示到达叶子层
deep = node.second;
continue;
}
pq.push(make_pair(node.first->left,node.second+1));
pq.push(make_pair(node.first->right,node.second+1));
}
return true;
}
//判断是否是满二叉树
//要根据层数来判断,如果当前层不是叶子层,那么必须每个节点都有两个子节点
//否则,每个节点都必须没有子节点,而且,如果判断出来的叶子层不是最高的一层,那么也不是满二叉树
bool Full_Binary_Tree(TreeNode* root)
{
if(root==nullptr) return false;
return BfsFull_Bin_Tree(root);
}
bool BfsNot_Com_Bin_Tree(TreeNode* root)
{
if(root==nullptr) return false;
queue<TreeNode*>pq;
while(!pq.empty()) pq.pop();
pq.push(root);
while(!pq.empty())
{
TreeNode* now = pq.front();
pq.pop();
if((now->left!=nullptr&&now->right==nullptr)||(now->left==nullptr&&now->right!=nullptr)) return false;
if(now->left!=nullptr) pq.push(now->left);
if(now->right!=nullptr) pq.push(now->right);
}
return true;
}
//判断是否是完满二叉树
//每个节点不然有两个子节点,不然有0个子节点
bool Not_Complete_Binary_Tree(TreeNode* root)
{
if(root==nullptr) return false;
return BfsNot_Com_Bin_Tree(root);
}
//构建二叉树
TreeNode* ConstructCore(int startpre,int endpre,int startin,int endin,int (&pre)[maxn],int (&in)[maxn],TreeNode* parent,int flag)
{
if(startpre>endpre||startin>endin) return nullptr;
int value = pre[startpre];
TreeNode* now = new TreeNode(value);
if(parent!=nullptr) {
if(flag==-1) {
parent->left = now;
}
else if(flag==1) {
parent->right = now;
}
}
//找到当前点的左右子树,并进行递归构建左右子树
int index = startin;
while(index<endin&&in[index]!=value) index++;
if(index==endin&&in[index]!=value) return nullptr;
//找到中序遍历中根节点,那么此时可以判断左右子树范围
int leftLength = index - startin;
int rightLength = endin - index;
//递归构建左右子树
if(leftLength>0) {
ConstructCore(startpre+1,startpre + leftLength , startin,index-1,pre,in,now,-1);
}
if(rightLength>0) {
ConstructCore(startpre+leftLength+1,endpre,index+1,endin,pre,in,now,1);
}
return now;
}
TreeNode* Construct(int startpre,int endpre,int startin,int endin,int (&pre)[maxn],int (&in)[maxn],int n)
{
if(n<=0) return nullptr;
return ConstructCore(startpre,endpre,startin,endin,pre,in,nullptr,-2);
}
};
int main()
{
int n;
scanf("%d",&n);
int pre[maxn],in[maxn];
for(int i = 0;i<n;i++)
scanf("%d",&pre[i]);
for(int i=0;i<n;i++)
scanf("%d",&in[i]);
Solution* sol = new Solution();
TreeNode* root = nullptr;
root = sol->Construct(0,n-1,0,n-1,pre,in,n);
vector<int>solve;
solve.clear();
sol->PreOrder(root,solve);
for(int i=0;i<solve.size();i++)
cout<<solve[i]<<" ";
cout<<endl;
solve.clear();
sol->InOrder(root,solve);
for(int i=0;i<solve.size();i++)
cout<<solve[i]<<" ";
cout<<endl;
solve.clear();
sol->AfterOrder(root,solve);
for(int i=0;i<solve.size();i++)
cout<<solve[i]<<" ";
cout<<endl;
solve.clear();
sol->bfsOrder(root,solve);
for(int i=0;i<solve.size();i++)
cout<<solve[i]<<" ";
cout<<endl;
return 0;
}