【LeetCode】199. 二叉树的右视图（类似NC136[more difficult]）

一、题目

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例:

输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:

   1            <---
 /   \
2     3         <---
 \     \
  5     4       <---

二、解决

1、BFS

思路： 对BFS模板略加修改即可。

代码：

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
                if (i == size - 1) {  //将当前层的最后一个节点放入结果列表
                    res.add(node.val);
                }
            }
        }
        return res;
    }
}

时间复杂度： $O(n)$
空间复杂度： $O(n)$

2、DFS

思路： 对DFS模板略加变动即可。
代码：

class Solution {
    List<Integer> res = new ArrayList<>();

    public List<Integer> rightSideView(TreeNode root) {
        dfs(root, 0); // 从根节点开始访问，根节点深度是0
        return res;
    }

    private void dfs(TreeNode root, int depth) {
        if (root == null) {
            return;
        }
        // 先访问 当前节点，再递归地访问 右子树 和 左子树。
        if (depth == res.size()) {   // 如果当前节点所在深度还没有出现在res里，说明在该深度下当前节点是第一个被访问的节点，因此将当前节点加入res中。
            res.add(root.val);
        }
        depth++;
        dfs(root.right, depth);
        dfs(root.left, depth);
    }
}

时间复杂度： $O(n)$
空间复杂度： $O(n)$

三、NC136

思路： 先重建二叉树，再返回遍历右视图结果。
代码：

import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 求二叉树的右视图
     * @param xianxu int整型一维数组 先序遍历
     * @param zhongxu int整型一维数组 中序遍历
     * @return int整型一维数组
     */
    int[] preOrder;
    HashMap<Integer, Integer> dic = new HashMap<>();
    public int[] solve (int[] xianxu, int[] zhongxu) {
        preOrder = xianxu;
        for (int i = 0; i < zhongxu.length; i++) {
            dic.put(zhongxu[i], i);
        }
        TreeNode root =  buildTree(0, 0, zhongxu.length - 1);
        return rightSideView(root);
    }
    
    public int[] rightSideView(TreeNode root) {
                Queue<TreeNode> q = new LinkedList<>();
        if (root != null) q.add(root);
        List<Integer> tmp = new ArrayList<>();
        while (!q.isEmpty()) {
            for (int i = q.size(); i > 0; i--) {
                TreeNode node = q.poll();
                if (node.left != null) q.add(node.left);
                if (node.right != null) q.add(node.right);
                if (i == 1) tmp.add(node.val);
            }
        }
//         return tmp;
        int[] res = new int[tmp.size()];
        for (int i = 0; i < res.length; i++) {
            res[i] = tmp.get(i);
        }
        return res;
    }
    
    public TreeNode buildTree(int preRoot, int inLeft, int inRight) {
        if (inLeft > inRight) return null;
        TreeNode root = new TreeNode(preOrder[preRoot]);
        int inRoot = dic.get(preOrder[preRoot]);
        root.left = buildTree(preRoot+1, inLeft, inRoot-1);
        root.right = buildTree(preRoot+inRoot-inLeft+1, inRoot+1, inRight);
        return root;
    }
     
}

时间复杂度： $O(n)$
空间复杂度： $O(n)$

四、参考

1、简单BFS/DFS, 🤷‍♀️必须秒懂！
2、Reverse Level Order Traversal, java
3、Share my Java iterative solution, based on level order traversal
4、My simple accepted solution(JAVA)