Leetcode 199. Binary Tree Right Side View

This problem can also be solved by BFS that is "reversed level order traverse".Save the first element of every BFS traverse level, then visit the right child first and left child.

 /**
  * BFS the tree, add every last node of a level to the result.
  * Therefore, we need to vist right child and put it to the queue first, then visit left child.
  */ 
public class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        
        if (root == null) {
            return res;
        }
        
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();            // level order BFS traverse
            res.add(queue.peek().val);              // add the right most element of a level to the result
            for (int i=0; i<size; i++) {
                TreeNode currNode = queue.poll();
                if (currNode.right != null)     // right child first
                    queue.offer(currNode.right);
                if (currNode.left != null)
                    queue.offer(currNode.left);
            }
        }
        
        return res;
    }
}

public class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> ret = new ArrayList<>();
        // the depth of root is 0
        rightView(0, root, ret);
        return ret;
    }
    
    public static void rightView(int depth, TreeNode t, List<Integer> ret) {
        if (t == null) return;
        
        // found a valid view
        if (ret.size() == depth) ret.add(t.val);
        
        // keep searching the left and right subtree
        // note that right subtree first b/c we need an right view
        rightView(depth+1, t.right, ret);
        rightView(depth+1, t.left, ret);
    }
}