牛客 二叉树 LeetCode105 从前序与中序遍历序列构造二叉树

题目描述
二叉树的前序、中序、后序遍历的定义： 前序遍历：对任一子树，先访问跟，然后遍历其左子树，最后遍历其右子树； 中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树； 后序遍历：对任一子树，先遍历其左子树，然后遍历其右子树，最后访问根。 给定一棵二叉树的前序遍历和中序遍历，求其后序遍历（提示：给定前序遍历与中序遍历能够唯一确定后序遍历）。
输入描述:
两个字符串，其长度n均小于等于26。
第一行为前序遍历，第二行为中序遍历。
二叉树中的结点名称以大写字母表示：A，B，C…最多26个结点。
输出描述:
输入样例可能有多组，对于每组测试样例，
输出一行，为后序遍历的字符串。
示例1
输入
复制
ABC
BAC
FDXEAG
XDEFAG
输出
复制
BCA
XEDGAF

思路

在中序中找到前序第一个结点，此节点可划分左子树和右字数，递归下去就好。

#include<iostream>
using namespace std;
void traversal(string pre,string ino)
{
    if(pre.size()==0)
        return;
    else
    {
        char first=pre[0];
        int index=post.find(first);
        traversal(pre.substr(1,index),ino.substr(0,index));
        traversal(pre.substr(index+1),ino.substr(index+1));
        cout<<pre[0];
    }   
}
int main()
{
    string pre,ino;
    while(cin>>pre>>ino)
    {
        traversal(pre,ino);
        cout<<endl;
    }
}

根据一棵树的前序遍历与中序遍历构造二叉树。
你可以假设树中没有重复的元素。
例如，给出
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：
3
/
9 20
/
15 7

同样的道理，划分左子树和右字数。

>题目描述
二叉树的前序、中序、后序遍历的定义： 前序遍历：对任一子树，先访问跟，然后遍历其左子树，最后遍历其右子树； 中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树； 后序遍历：对任一子树，先遍历其左子树，然后遍历其右子树，最后访问根。 给定一棵二叉树的前序遍历和中序遍历，求其后序遍历（提示：给定前序遍历与中序遍历能够唯一确定后序遍历）。
输入描述:
两个字符串，其长度n均小于等于26。
第一行为前序遍历，第二行为中序遍历。
二叉树中的结点名称以大写字母表示：A，B，C....最多26个结点。
输出描述:
输入样例可能有多组，对于每组测试样例，
输出一行，为后序遍历的字符串。
示例1
输入
复制
ABC
BAC
FDXEAG
XDEFAG
输出
复制
BCA
XEDGAF

# 思路
在中序中找到前序第一个结点，此节点可划分左子树和右字数，递归下去就好。
```cpp
#include<iostream>
using namespace std;
void traversal(string pre,string ino)
{
    if(pre.size()==0)
        return;
    else
    {
        char first=pre[0];
        int index=ino.find(first);
        traversal(pre.substr(1,index),ino.substr(0,index));
        traversal(pre.substr(index+1),ino.substr(index+1));
        cout<<pre[0];
    }   
}
int main()
{
    string pre,ino;
    while(cin>>pre>>ino)
    {
        traversal(pre,ino);
        cout<<endl;
    }
}

根据一棵树的前序遍历与中序遍历构造二叉树。
你可以假设树中没有重复的元素。
例如，给出
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：
3
/
9 20
/
15 7

同样的道理，划分左子树和右字数。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size()==0)  return NULL;
        //新建结点
        TreeNode*root=new TreeNode(preorder[0]);
        int index;
        //找到划分位置
        for(index=0;index<inorder.size();index++)
            if(inorder[index]==preorder[0]) break;
       //划分
        vector<int> pre_left,inor_left,pre_right,inor_right;
        for(int i=0;i<index;i++)
        {
            pre_left.push_back(preorder[i+1]);
            inor_left.push_back(inorder[i]);
        }
        for(int i=index+1;i<inorder.size();i++)
        {
            pre_right.push_back(preorder[i]);
            inor_right.push_back(inorder[i]);
        }
        root->left=buildTree(pre_left,inor_left);
        root->right=buildTree(pre_right,inor_right);

        return root;
        
    }
};

python不香吗

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        if len(preorder)==0:
            return None
        root=TreeNode(preorder[0])
        index=inorder.index(preorder[0])
        root.left=self.buildTree(preorder[1:index+1],inorder[0:index])
        root.right=self.buildTree(preorder[index+1:],inorder[index+1:])
        return root