Java reconstruye el árbol binario en función de la matriz de pedido anticipado y de orden medio y devuelve la vista derecha del árbol binario

Vista derecha del árbol binario

https://blog.csdn.net/m0_37605197/article/details/105836456

Descripción del Título

Siga el recorrido de pedido previo del árbol binario, el recorrido de orden medio para restaurar el árbol binario e imprima la vista derecha del árbol binario

Ejemplo 1

entrar

[1,2,4,5,3],[4,2,5,1,3]

valor de retorno

[1,3,5]

 

import java.util.*;


public class Solution {

      List<Integer> list = new ArrayList<>();

    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 求二叉树的右视图
     * @param xianxu int整型一维数组 先序遍历
     * @param zhongxu int整型一维数组 中序遍历
     * @return int整型一维数组
     */
    public int[] solve (int[] xianxu, int[] zhongxu) {
       
        if(xianxu.length == 0 || zhongxu.length == 0){
            return null;
        }
        TreeNode tree = rebuildTree(xianxu,zhongxu);
 
        
        //计算右子树的size 并前序遍历保存右子树节点到queue中
       List<Integer> resultList = rightSideView(tree);

        //加上一个根节点的长度
        int[] result = new int[resultList.size()];
        for(int i=0;i<resultList.size();i++){
            result[i] = resultList.get(i);
        }
        
        return result;
    }
    
    public TreeNode rebuildTree(int[] pre,int[] mid){
        
        if(pre.length == 0 || mid.length == 0){
            return null;
        }
        
        int root = pre[0];
        int midIndex = 0;
        for(int i=0;i<mid.length;i++){
            if(root == mid[i]){
                midIndex = i;
                break;
            }
        }
        
        TreeNode tree = new TreeNode(root);
        tree.left = rebuildTree(Arrays.copyOfRange(pre,1,midIndex+1),Arrays.copyOfRange(mid,0,midIndex));
        tree.right = rebuildTree(Arrays.copyOfRange(pre,midIndex+1,pre.length),Arrays.copyOfRange(mid,midIndex+1,mid.length));
                                 
        return tree;
    }
                     
    /**
     * 获取二叉树右视图
     * 给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
     *                         1
     *                     /       \
     *                 2               4
     *              /               /     \
     *           8               5           3
     *                             \
     *                               6
     *                              /
     *                             7
     * @param root
     * @return
     */
    public List<Integer> rightSideView(TreeNode root) {
        list = new ArrayList();
        dfs(root,0);
        return list;
    }
    
    //按照“根-右-左”的顺序，下一层第一个被访问的就是最右节点（跟先序遍历相反）
    public void dfs(TreeNode node,int depth){
        if(node==null) return;
        if(depth==list.size()) list.add(node.val);
        dfs(node.right,depth+1);
        dfs(node.left,depth+1);
    }
    
}