Codestin Search App

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

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

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!

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
✓ 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)	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) — Algorithm Steps

Traverse the entire tree using DFS or BFS
Store each node's value along with its level in a data structure
Group nodes by their level
For each level, select the rightmost (last) node
Return the rightmost nodes in level order

Visualization

Tap to expand

Step-by-Step Walkthrough

Visit All Nodes

Traverse the entire tree and store each node with its level

Group by Levels

Organize all collected nodes by their depth level

Select Rightmost

From each level's group, pick the last (rightmost) node

Code -

solution.c — C

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

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

struct LevelNodes {
    int *nodes;
    int count;
    int capacity;
};

void dfs(struct TreeNode* node, int level, struct LevelNodes* levels, int* maxLevel) {
    if (!node) return;
    
    if (level > *maxLevel) {
        *maxLevel = level;
    }
    
    if (levels[level].capacity == 0) {
        levels[level].capacity = 10;
        levels[level].nodes = malloc(sizeof(int) * 10);
        levels[level].count = 0;
    }
    
    if (levels[level].count >= levels[level].capacity) {
        levels[level].capacity *= 2;
        levels[level].nodes = realloc(levels[level].nodes, sizeof(int) * levels[level].capacity);
    }
    
    levels[level].nodes[levels[level].count++] = node->val;
    
    dfs(node->left, level + 1, levels, maxLevel);
    dfs(node->right, level + 1, levels, maxLevel);
}

int* rightSideView(struct TreeNode* root, int* returnSize) {
    *returnSize = 0;
    if (!root) return NULL;
    
    struct LevelNodes levels[1000] = {0};
    int maxLevel = -1;
    
    dfs(root, 0, levels, &maxLevel);
    
    int* result = malloc(sizeof(int) * (maxLevel + 1));
    for (int i = 0; i <= maxLevel; i++) {
        result[i] = levels[i].nodes[levels[i].count - 1];
    }
    
    *returnSize = maxLevel + 1;
    
    for (int i = 0; i <= maxLevel; i++) {
        free(levels[i].nodes);
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit every node once, then process each level

✓ Linear Growth

Space Complexity

O(n)

Store all nodes in the tree grouped by levels

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (All Nodes with Level Tracking) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler