Binary Tree Right Side View - Practice Coding Problems

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.

When you stand on the right side, you can only see the rightmost node at each level of the tree.

Example: For a tree with root [3,9,20,null,null,15,7], you would see nodes with values [3,20,7] - one from each level, taking the rightmost visible node.

Input & Output

Example 1 — Standard Tree

$ Input: root = [3,9,20,null,null,15,7]

› Output: [3,20,7]

💡 Note: Level 0: only node 3 is visible. Level 1: nodes 9 and 20, but only 20 is rightmost. Level 2: nodes 15 and 7, but only 7 is rightmost.

Example 2 — Right-Skewed Tree

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

› Output: [1,3]

💡 Note: Level 0: node 1 is visible. Level 1: only node 3 exists and is rightmost.

Example 3 — Single Node

$ Input: root = [1]

› Output: [1]

💡 Note: Only one node exists, so it's the only node visible from the right side.

Constraints

The number of nodes in the tree is in the range [0, 100]
-100 ≤ Node.val ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Input Tree

Binary tree with nodes at multiple levels

Right Side View

Only rightmost node at each level is visible

Output Array

Values of visible nodes from top to bottom

Key Takeaway

🎯 Key Insight: At each level of the tree, only the rightmost node is visible from the right side view

Asked in

F Facebook 45 a Amazon 38 M Microsoft 25

The key insight is to identify the rightmost node at each level. Best approach is BFS level-order traversal - process nodes level by level and take the last node from each level. Time: O(n), Space: O(w) where w is tree width.

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Level Tracking	O(n)	O(h)	Use DFS to visit all nodes while tracking the first node seen at each level from right side
BFS Level Order Traversal	O(n)	O(w)	Use BFS to process nodes level by level, taking the last node from each level

DFS with Level Tracking — Algorithm Steps

Start DFS from root, prioritizing right subtree
Track current level depth
For each new level encountered, record the node value
Return collected values in top-to-bottom order

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Begin DFS from root, level 0

Right-First Search

Visit right subtree before left at each level

Record First Seen

First node encountered at each level is rightmost

Code -

solution.c — C

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

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

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

void dfs(struct TreeNode* node, int level, int* result, int* resultSize) {
    if (!node) return;
    
    // If this is the first node we see at this level
    if (level == *resultSize) {
        result[*resultSize] = node->val;
        (*resultSize)++;
    }
    
    // Visit right first, then left
    dfs(node->right, level + 1, result, resultSize);
    dfs(node->left, level + 1, result, resultSize);
}

int* solution(struct TreeNode* root, int* returnSize) {
    int* result = (int*)malloc(1000 * sizeof(int));
    *returnSize = 0;
    
    if (!root) return result;
    
    dfs(root, 0, result, returnSize);
    return result;
}

int main() {
    // For simplicity, we'll handle a basic test case
    struct TreeNode* root = createNode(1);
    root->left = createNode(2);
    root->right = createNode(3);
    root->left->right = createNode(5);
    root->right->right = createNode(4);
    
    int returnSize;
    int* result = solution(root, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node once in the tree

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, plus result array

✓ Linear Space

338.0K Views

High Frequency

~15 min Avg. Time

8.5K 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

Constraints

Visualization

Related Problems

Common Approaches

DFS with Level Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler