输出二叉树的右视图

function TreeNode(x){
    this.val=x
    this.left=null
    this.right=null
}
function build(pre,vin){
        if(!pre.length||!vin.length) return
        let root=new TreeNode(pre.shift())
        let index=vin.indexOf(root.val)
        root.left=build(pre,vin.slice(0,index))
        root.right=build(pre,vin.slice(index+1))
        return root
}
function solve( xianxu ,  zhongxu ) {
    // write code here
    //重建二叉树
    let root=build(xianxu,zhongxu)
    //怎末输出右视图，就是把每层的level最后一个元素输出一下
    let a=[]
    let b=[]
    function level(root,l){
        if(!root)return
        i***efined) a[l]=[]
        a[l].push(root.val)
        level(root.left,l+1)
        level(root.right,l+1)
    }
    level(root,0)
    for(let i=0;i<a.length;i++){
      b[i]=a[i][a[i].length-1]
    }
    return b
}

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 * 求二叉树的右视图
 * @param xianxu int整型一维数组 先序遍历
 * @param zhongxu int整型一维数组 中序遍历
 * @return int整型一维数组
 */
function solve( xianxu ,  zhongxu ) {
    // write code here
    //构建二叉树    
    const f = ((preorder,inorder)=>{
        if(preorder.length <= 0 || inorder.length <= 0) return null;
        let root = new TreeNode(preorder[0]);
        let index = inorder.indexOf(root.val);
        preorder.shift();
        root.left = f(preorder, inorder.slice(0, index));
        root.right = f(preorder, inorder.slice(index + 1));
        return root;
    });
    let pRoot = f(xianxu,zhongxu);
    
    //层序遍历
    const res = [];
    const que = [];
    que.push(pRoot);
    while(que.length > 0){
        const len = que.length;        
        for(let i = 0; i < len; i++){
            let tem = que.shift();
            if(i === len - 1) res.push(tem.val);
            if(tem.left) que.push(tem.left);
            if(tem.right) que.push(tem.right);
        }
    }
    return res;
}
module.exports = {
    solve : solve
};

function solve( xianxu ,  zhongxu ) {
    const root = buildTree(xianxu, zhongxu);
    const rightView = getRightView(root);
    return rightView;
}
function buildTree(xianxu, zhongxu) {
    if (xianxu.length === 0) return null;
    const root = new TreeNode(xianxu[0]);
    const index = zhongxu.indexOf(root.val);
    const lefts = zhongxu.slice(0, index);
    const rights = zhongxu.slice(index + 1);
    root.left = buildTree(xianxu.slice(1, lefts.length + 1), lefts);
    root.right = buildTree(xianxu.slice(lefts.length + 1), rights);
    return root;
}
function getRightView(root) {
    const res = [];
    let stack = [root];
    while (stack.length) {
        const rowLen = stack.length;
        const newStack = [];
        for (let i = 0; i < rowLen; i++) {
            const node = stack[i];
            if (i === stack.length - 1) res.push(node.val);
            if (node.left) newStack.push(node.left);
            if (node.right) newStack.push(node.right);
        }
        stack = newStack;
    }
    return res;
}

function solve( xianxu ,  zhongxu ) {
    // write code here
     //重建二叉树
    function buildTree(pre, vin) {
        if(pre.length == 0 || vin.length == 0) return null
        let root = new TreeNode(pre[0]), i = vin.indexOf(pre[0])
        root.left = buildTree(pre.slice(1, i+1), vin.slice(0,i))
        root.right = buildTree(pre.slice(i+1), vin.slice(i+1))
        return root
    }
   let root  = buildTree(xianxu, zhongxu)
   //dfs
   if(!root) return []
    let arr = []
    dfs(root, 0 , arr)
    return arr
    function dfs(root, depth, res){
        if(root){
            if(res.length == depth){
                res.push(root.val)// 当数组长度等于当前 深度 时, 把当前的值加入数组
            }
            dfs(root.right, depth +1 ,res) // 先从右边开始, 当右边没了, 再轮到左边
            dfs(root.left, depth+1, res)
        }
    }
}

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 * 求二叉树的右视图
 * @param xianxu int整型一维数组 先序遍历
 * @param zhongxu int整型一维数组 中序遍历
 * @return int整型一维数组
 */
function solve( xianxu ,  zhongxu ) {
    // write code here
    let node = rebuild(xianxu, zhongxu);
//     return rightView(node);
    return rightViewDFS(node);
}
function TreeNode(val){
    this.val = val;
    this.left = null;
    this.right = null;
}
function rebuild(preOrder, inOrder){
    if(!preOrder.length || !inOrder.length) return null;
    let val = preOrder[0],
        node = new TreeNode(val);
    let i = 0;
    for(let len = inOrder.length; i < len; i++){
        if(inOrder[i] === val) break;
    }
    node.left = rebuild(preOrder.slice(1, i + 1), inOrder.slice(0, i));
    node.right = rebuild(preOrder.slice(i + 1), inOrder.slice(i + 1));
    console.log(node)
    return node;
}
function rightView(root){
    if(!root) return [];
    let res = [],
        queue = [root];
    while(queue.length){
        let len = queue.length;
        for(let i = 0; i < len; i++){
            let node = queue.shift();
            if(i === len - 1){
                res.push(node.val);
            }
            if(node.left){
                queue.push(node.left);
            }
            if(node.right){
                queue.push(node.right)
            }
        }
    }
    return res;
}
function rightViewDFS(root){
    let res = [];
    if(!root) return res;
    dfs(root, res, 0);
    return res;
}
function dfs(node, res, depth){
    if(!node) return;
    if(res.length === depth){
        res.push(node.val);
    }
    dfs(node.right, res, depth + 1);
    dfs(node.left, res, depth + 1);
 }
module.exports = {
    solve : solve
};