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

题目描述

// 199. 二叉树的右视图

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

题解

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

// 层序遍历法 / BFS
// 还记得【剑指offer】32.2 从上到下打印二叉树2 中我们可以得到分层版的
// 层序遍历，取每个层的最右边元素放到新list中，直接返回list即可。

// 执行用时：2 ms, 在所有 Java 提交中击败了21.85%的用户
// 内存消耗：38.2 MB, 在所有 Java 提交中击败了10.20%的用户
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null)
            return res;

        List<List<Integer>> list = new ArrayList<>();
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        while (!q.isEmpty()) {
            List<Integer> level = new ArrayList<>();
            int len = q.size();
            while (len > 0) {
                TreeNode node = q.remove();
                level.add(node.val);
                if (node.left != null)
                    q.add(node.left);
                if (node.right != null)
                    q.add(node.right);
                len--;
            }
            list.add(level);
        }
        for (List<Integer> sublist: list) {
            res.add(sublist.get(sublist.size() - 1));
        }
        return res;
    }
}

// 优化一下
// 不需要层信息level放入到总list中，所以也不需要总list。
// 直接在我们完成level时取level最右侧元素
// 
// 执行用时：1 ms, 在所有 Java 提交中击败了99.46%的用户
// 内存消耗：38.3 MB, 在所有 Java 提交中击败了9.05%的用户
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null)
            return res;

        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        while (!q.isEmpty()) {
            List<Integer> level = new ArrayList<>();
            int len = q.size();
            while (len > 0) {
                TreeNode node = q.remove();
                level.add(node.val);
                if (node.left != null)
                    q.add(node.left);
                if (node.right != null)
                    q.add(node.right);
                len--;
            }
            res.add(level.get(level.size() - 1));
        }

        return res;
    }
}


// 再优化一下
// 既然是要level的最后一个元素，那么可以去掉while循环，把len累减减干净这种
// 操作，而是直接计数，从0数到len - 1的时候，那此时存进level的元素
// 一定是当前层level的最右边的元素。

// 执行用时：2 ms, 在所有 Java 提交中击败了21.85%的用户
// 内存消耗：38.2 MB, 在所有 Java 提交中击败了10.01%的用户
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null)
            return res;

        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        while (!q.isEmpty()) {
            List<Integer> level = new ArrayList<>();
            int len = q.size();
            for (int i = 0; i < len; i++) {
                TreeNode node = q.remove();
                level.add(node.val);
                if (node.left != null)
                    q.add(node.left);
                if (node.right != null)
                    q.add(node.right);
                if (i == len - 1) 
                    res.add(level.get(i));
            }
        }

        return res;
    }
}


// 再再优化一下
// 那么既然我们可以计数一直数到len-1个元素，就是我们要的最右侧元素，
// 那还要level干嘛？就不需要level了，直接数到len-1个元素，把此时的node.val
// 放进去res就好了，这里跟level都没关系了。

// 执行用时：2 ms, 在所有 Java 提交中击败了21.85%的用户
// 内存消耗：36.6 MB, 在所有 Java 提交中击败了99.59%的用户
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null)
            return res;

        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        while (!q.isEmpty()) {
            int len = q.size();
            for (int i = 0; i < len; i++) {
                TreeNode node = q.remove();
                if (node.left != null)
                    q.add(node.left);
                if (node.right != null)
                    q.add(node.right);
                if (i == len - 1) 
                    res.add(node.val);
            }
        }

        return res;
    }
}

// DFS
// 前序遍历(根->左子节点->右子结点)遍历的是二叉树最左侧的结点，
// 我们可以反过来做一个 根->右子结点->左子节点 的反前序遍历，寻找
// 二叉树最右侧的结点。
// 假如我们有实例二叉树如下：
//        ///
//        //         5         //
//        //       /   |       //
//        //      3    6       //
//        //    /  |    |      //
//        //   2   1    8      //
//        //       |           //
//        //       7           //
//        ///
// 如果是单纯的按照 根->右子结点->左子节点 的遍历方式，确实可以考虑到
// 5 6 8这三个最右侧结点，但是没办法考虑到7这个同样也是右视图的结点。
// 解决办法是，新增一个深度记录位depth，记录遍历过的节点最深深度，只当当前
// 深度等于答案数组res的size（res的深度）时，那么此时加入下一个元素进res，
// 才是对res元素的深度拓展增益。说明下一个一定是比此前的res中的结点元素更深，
// 这样的设计，就能够使得实例中的结点7可以被加入res，而7之前的1 3都不会加入
// 到res中。
// 元素存入res之后，depth累加一次，如此循环递归下去。
// 执行用时：1 ms, 在所有 Java 提交中击败了99.46%的用户
// 内存消耗：37 MB, 在所有 Java 提交中击败了77.33%的用户
class Solution {
	List<Integer> res = new ArrayList<>();
	
	public List<Integer> rightSideView(TreeNode root) {
		dfs(root, 0);
        return res;
    }
	
	public void dfs(TreeNode root, int depth) {
		if (root == null)
			return;
		if (depth == res.size())
			res.add(root.val);
		depth++;
		dfs(root.right, depth);
		dfs(root.left, depth);
	}
}