Binary Tree Right Side View

MediumTree BFSNeetCode 150MidOpen on LeetCodeUpdated Sep 21, 2026

You're given the root of a binary tree. Picture standing to its right: on each level you see only the rightmost node, and the rest of that level is hidden behind it. Return the visible values from the root down to the deepest level. A level's rightmost node can be a left child when nothing sits further right. An empty tree returns an empty list. Example trees are listed row by row from the top, each row left to right, with null where a child is missing.

Examples

root = [1,2,3,null,5,null,4] returns [1,3,4]

The rightmost node on each level is 1, then 3, then 4. The 5 on the bottom level is hidden behind 4, which sits further right.

root = [1,null,3] returns [1,3]

The root 1 has only a right child 3, so each level has a single node and both are visible.

root = [1,2,3,4,null,null,null,5] returns [1,3,4,5]

4 and 5 are visible because nothing on their levels sits to their right.

The third level holds only 4, the left child of 2, so it is visible even though it is on the left. Below it, 5 is alone on the fourth level.

Constraints

0 <= number of nodes <= 100

Hints

Hint 1

From each row of the tree, which single node is visible from the right side?

Hint 2

A pointer toward the approach

Hint 3

The full approach, step by step

Drill This: Your Approach First

Answer, Then Reveal

In two or three sentences, how would you solve it and what's the complexity?

Skip to Reading

Approach

Traverse level by level with a queue. For each level, snapshot the queue's size, pop that many nodes while pushing their children left then right, and record the value of the last node popped (index size - 1). Because children are pushed left to right, the last node of each level is the rightmost one at that depth, wherever its parent is. O(n) time, O(n) space for the queue.

Time

O(n)

Space

O(n)

Pitfall

Only following right children. A level's rightmost node can sit in a left subtree when the right side is shorter, as with 4 in [1,2,3,4], so every level has to be scanned in full.

Solutions

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) return result;
        Deque<TreeNode> queue = new ArrayDeque<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (i == size - 1) result.add(node.val);
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
            }
        }
        return result;
    }
}

from collections import deque

class Solution:
    def rightSideView(self, root):
        result = []
        if not root:
            return result
        queue = deque([root])
        while queue:
            size = len(queue)
            for i in range(size):
                node = queue.popleft()
                if i == size - 1:
                    result.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return result