Binary Tree Right Side View - Practice Coding Problems

Binary Tree Right Side View - Problem

Imagine you're standing on the right side of a binary tree, looking at it from that perspective. You can only see certain nodes - specifically, the rightmost node at each level.

Given the root of a binary tree, return the values of the nodes you can see when viewing the tree from the right side, ordered from top to bottom.

For example, if you have a tree where level 0 has node 1, level 1 has nodes 2 and 3, and level 2 has node 5 under node 2, then from the right side you would see: [1, 3, 5] - the rightmost node at each level.

Input & Output

example_1.py — Standard Binary Tree

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

› Output: [1,3,4]

💡 Note: From the right side: Level 0 shows node 1, Level 1 shows node 3 (rightmost), Level 2 shows node 4 (rightmost)

example_2.py — Right-Heavy Tree

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

› Output: [1,3]

💡 Note: Only has right children, so we see node 1 at level 0 and node 3 at level 1

example_3.py — Single Node

$ Input: root = [1]

› Output: [1]

💡 Note: Only one node exists, so the right side view contains just that node

Visualization

Tap to expand

Understanding the Visualization

Position Camera

Stand on the right side of the building (tree) with your camera

Capture Each Floor

For each floor (level), only the rightmost room (node) is visible

Smart Strategy

Instead of checking every room, explore right corridors first - the first room you find on each new floor is automatically the rightmost!

Key Takeaway

🎯 Key Insight: By exploring the building right-first (DFS with right child priority), the first room you discover on each new floor is guaranteed to be the rightmost room visible from the outside!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during BFS traversal

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most the maximum width of tree (nodes at one level)

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 100]
Node values are in the range [-100, 100]
Tree height will not exceed 100 levels

Asked in

f Meta 42 a Amazon 38 ⊞ Microsoft 31 G Google 28

The optimal solution uses right-first DFS traversal. By visiting the right subtree before the left subtree at each level, the first node we encounter at any level is guaranteed to be the rightmost node at that level. This achieves O(n) time and O(h) space complexity where h is the tree height.

Common Approaches

Approach	Time	Space	Notes
✓ Level-Order BFS (Optimal)	O(n)	O(w)	Use BFS to process nodes level by level, always picking the rightmost node from each level
Brute Force (All Nodes with Level Tracking)	O(n)	O(n)	Visit all nodes, store them by level, then extract rightmost from each level

Level-Order BFS (Optimal) — Algorithm Steps

Use a queue to perform level-order traversal (BFS)
For each level, process all nodes in that level
Keep track of the last (rightmost) node in each level
Add the rightmost node value to the result
Continue until all levels are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Begin DFS traversal at root with level 0

Visit Right First

At each node, explore right subtree before left subtree

First at Level

The first time we encounter a new level, that node is the rightmost

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

void dfs(struct TreeNode* node, int level, int* result, int* returnSize, int* maxLevel) {
    if (!node) return;
    
    if (level > *maxLevel) {
        *maxLevel = level;
        result[*returnSize] = node->val;
        (*returnSize)++;
    }
    
    dfs(node->right, level + 1, result, returnSize, maxLevel);
    dfs(node->left, level + 1, result, returnSize, maxLevel);
}

int* rightSideView(struct TreeNode* root, int* returnSize) {
    *returnSize = 0;
    if (!root) return NULL;
    
    int* result = malloc(sizeof(int) * 100);
    int maxLevel = -1;
    
    dfs(root, 0, result, returnSize, &maxLevel);
    
    return result;
}

int main() {
    int returnSize;
    int* result = rightSideView(NULL, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    printf("\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during BFS traversal

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most the maximum width of tree (nodes at one level)

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 100]
Node values are in the range [-100, 100]
Tree height will not exceed 100 levels

186.5K Views

High Frequency

~15 min Avg. Time

8.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Level-Order BFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler