Binary Tree Right Side View

Problem

Given the root of a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.

Example 1:

Input: root = [1,2,3,null,5,null,4]
Output: [1,3,4]

Example 2:

Input: root = [1,null,3]
Output: [1,3]

Example 3:

Input: root = []
Output: []

Intuition

The task is to imagine standing on the right side of a binary tree and returning the values of the nodes visible from that perspective. The intuition is to perform a level order traversal of the binary tree and, for each level, only consider the value of the rightmost node, as that would be the one visible from the right side.

Approach

Initialization:

Check if the root is None. If so, return an empty list since there are no nodes to traverse.
Breadth-First Search (BFS):

Use a queue (in this case, a deque) to perform a breadth-first traversal of the binary tree.
Initialize the queue with the root node.
Right Side View:

While the queue is not empty:
For each level, create a temporary list (temp) to store the values of nodes.
Process all nodes at the current level:
Pop the front node from the queue.
Enqueue its left and right children (if any).
Append the value of the current node to the temp list.
If the temp list is not empty, append the value of the rightmost node to the final result (stack).
Return Result:

Return the final result, which is a list of values representing the nodes visible from the right side.

Complexity

• Time complexity:

The time complexity is O(n), where n is the number of nodes in the binary tree. Each node is visited exactly once during the traversal.

• Space complexity:

The space complexity is O(m), where m is the maximum number of nodes at any level in the binary tree. In the worst case, the maximum number of nodes at any level is the number of leaf nodes, which is at most n/2 in a balanced binary tree. Therefore, the space complexity is O(n/2), which simplifies to O(n) in big-O notation. This is because the space required to store nodes at any level scales with the number of nodes in the tree.

Code

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []

        stack = [root.val]
        q = deque([root])
        while q:
            temp = []
            for _ in range(len(q)):
                node = q.popleft()
                if node.left:
                    q.append(node.left)
                    temp.append(node.left.val)
                if node.right:
                    q.append(node.right)
                    temp.append(node.right.val)

            if temp:
                stack.append(temp[-1])

        return stack