Leetcode【树 DFS BFS】| 199. 二叉树的右视图

题目

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
示例:
　输入: [1,2,3,null,5,null,4]
　输出: [1, 3, 4]
　解释:
　 　 　1 <—
　　　／ ＼
　 　 2　　3 <—
　　／＼ ／ ＼
　null　5 null 4 <—
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-right-side-view

解题

DFS解法

看到题目第一反应就是用深度优先搜索，沿着树的深度一直遍历出最右边的节点。本来想的很简单，从第一层开始一直返回右节点的右节点的右…，但是仔细一想，当某一层的右节点没有的时候，这层的最右可能就是第一层的左子树下面的，这时候就需要回溯，一直到这层的左子树的右节点的右节点的右…如下图示例，红色的结点即为右视图看到的结点，箭头表示遍历过程：

这个思路自己能想到，但是代码自己没想通，其实只是少想到了一个条件，就是回溯的时候怎么确定到哪个点又是下一层的最右节点？这个判断条件的关键就是加一个记录已计算到哪一层的最右节点的层数depth（res.size）。
这样回溯的时候到还未记录过的那一层depth＋1层的节点时很明显那个就是那一层的最右节点（因为我们深度遍历是先右后左）
回溯的节点层数是递归一次，层数加一这样实时计算出来的。
代码参考 Jacky:优先右子树的深度遍历 清晰高效的递归解法实现的太妙了。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    List<Integer> res = new ArrayList<>();
    int deepest = 0;//当前遍历到哪一层
    public List<Integer> rightSideView(TreeNode root) {
        //递归
        dfs(root,0);
        return res;
    }
    private void dfs(TreeNode root,int now){
        if(root == null) return;
        if(now == deepest){
            res.add(root.val);
            deepest++;
        }
        dfs(root.right,now+1);//先把右节点的右节点都有的弄出来，直到该层的右节点没了，deepest也增加到这层了
        //下一步深度遍历左节点，就是回溯了，小于deepest的在上一步now==deepest的时候都过滤掉了不会加入res,直到deepest这层，找到左节点的下面这支的最右的
        dfs(root.left,now+1);
    }
}

以下是另一种写法，代码稍稍的不同，其实就是一样的。少创建一个上面的deepest，下面的depth就是上面的now递归方法中的当前层，上面多出的deepest变量是当前结果已经计算到的右节点的层数直接用res.size求解出不用额外创建变量计算，参考力扣题解

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);
    }
}

node的左节点：node.left
node的右节点：node.right
结点的值：node.val

BFS解法

另一种就是广度优先的遍历。因为广度优先的策略是依次遍历每一层的所有结点再进行下一层，所以我们依照广度优先的实现方法依次返回每一层的所有节点中的最右结点，就得到了所求右视图。代码参考 kaiscript: BFS层次遍历java实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        //获取每一层的最后一个结点
        if(root == null){
            return new ArrayList<>();
        }
        List<Integer> res = new ArrayList<>();

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            //因为每次都把弹出节点的子节点都压入，所以这个for循环相当于循环一层，把这层的都弹出再压入
            int size = queue.size();
            for(int i = 0; i <size;i++){
                TreeNode head = queue.poll();//弹出一个结点
                if(i == size-1){
                    res.add(head.val);//到最后一个节点了
                }
                //压入弹出节点head的左右节点

                if(head.left != null){
                    queue.offer(head.left);
                }
                if(head.right != null){
                    queue.offer(head.right);
                }
            }
        }
        return res;
    }
}