输出二叉树的右视图

题目

请根据二叉树的前序遍历，中序遍历恢复二叉树，并打印出二叉树的右视图
数据范围： 0≤n≤10000
要求： 空间复杂度 O(n)，时间复杂度 O(n)
如输入[1,2,4,5,3],[4,2,5,1,3]时，通过前序遍历的结果[1,2,4,5,3]和中序遍历的结果[4,2,5,1,3]可重建出二叉树

思路

通过中序遍历和先序遍历的结果+递归可以重新构建出二叉树，然后采用层次遍历的方法记录每一层最后一个节点的值。

代码

python版本：

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 求二叉树的右视图
# @param xianxu int整型一维数组 先序遍历
# @param zhongxu int整型一维数组 中序遍历
# @return int整型一维数组
#
class Solution:
    def solve(self , xianxu: List[int], zhongxu: List[int]) -> List[int]:
        # write code here
        # 根据前序遍历和中序遍历来重构二叉树
        root = self.rebuild_tree(xianxu, zhongxu)
        queue = [root]
        # 采用层次遍历来记录每个层的最后一个节点的值
        res = []
        while(len(queue)):
            node_num_per_level = len(queue)
            for i in range(node_num_per_level):
                node = queue.pop()
                if(i==node_num_per_level-1):
                    res.append(node.val)
                if(node.left):
                    queue.insert(0, node.left)
                if(node.right):
                    queue.insert(0, node.right)
        return res
    
    def rebuild_tree(self, xianxu: List[int], zhongxu: List[int]):
        if not xianxu:
            return None
        root = TreeNode(xianxu[0])
        dis = zhongxu.index(xianxu[0])
        root.left = self.rebuild_tree(xianxu[1:1+dis], zhongxu[0:dis])
        root.right = self.rebuild_tree(xianxu[1+dis:], zhongxu[dis+1:])
        return root;

c++版本：

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 求二叉树的右视图
     * @param xianxu int整型vector 先序遍历
     * @param zhongxu int整型vector 中序遍历
     * @return int整型vector
     */
    vector<int> solve(vector<int>& xianxu, vector<int>& zhongxu) {
        // write code here
        // 前序，根左右
        // 中序，左根右
        TreeNode *root=rebuild_tree(xianxu, zhongxu);
        //层次遍历
        queue<TreeNode*> queue_tree;
        queue_tree.push(root);
        vector<int> res;
        while(!queue_tree.empty()){
            int node_num_pre_level = queue_tree.size();
            for(int i=0; i<node_num_pre_level; i++){
                TreeNode *node = queue_tree.front();
                if(i==node_num_pre_level-1){
                    res.push_back(node->val);
                }
                queue_tree.pop();
                if(node->left){
                    queue_tree.push(node->left);
                }
                if(node->right){
                    queue_tree.push(node->right);
                }
            }
        }
        return res;
    }
    TreeNode* rebuild_tree(vector<int>& xianxu, vector<int>& zhongxu){
        if(xianxu.empty()){
            return nullptr;
        }
        TreeNode *root = new TreeNode(xianxu[0]);
        vector<int>::iterator it = find(zhongxu.begin(), zhongxu.end(), xianxu[0]);
        int dis = distance(zhongxu.begin(), it);
        vector<int> xianxu_left(xianxu.begin()+1, xianxu.begin()+dis+1);
        vector<int> xianxu_right(xianxu.begin()+1+dis, xianxu.end());
        vector<int> zhongxu_left(zhongxu.begin(), zhongxu.begin()+dis);
        vector<int> zhongxu_right(zhongxu.begin()+dis+1, zhongxu.end());
        root->left=rebuild_tree(xianxu_left, zhongxu_left);
        root->right=rebuild_tree(xianxu_right, zhongxu_right);
        return root;
    }
};