Binary Tree Right Side View

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

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

✓ BFS Level Order Traversal

⏱️ Time: O(n) Space: O(w)

Perform breadth-first search to traverse the tree level by level. For each level, the last node processed will be the rightmost node, which is what we see from the right side.

DFS with Level Tracking

⏱️ Time: O(n) Space: O(h)

Perform a depth-first search starting from the right subtree. For each level, record the first node we encounter (which will be the rightmost due to right-first traversal).

BFS Level Order Traversal — Algorithm Steps

Use queue to process nodes level by level
For each level, process all nodes and track the last one
Add the last node's value to result
Continue until all levels are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0

Process root level, take last node

Level 1

Process all nodes at level 1, take rightmost

Continue

Repeat for all levels until queue is empty

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.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;
}

static char input[10000];
static int values[1000];
static int isNull[1000];

int parseArray(char* str) {
    int count = 0;
    int i = 0;
    
    // Skip initial '['
    while (str[i] && str[i] != '[') i++;
    if (str[i] == '[') i++;
    
    while (str[i] && str[i] != ']') {
        // Skip whitespace and commas
        while (str[i] && (isspace(str[i]) || str[i] == ',')) i++;
        
        if (str[i] == ']') break;
        
        // Check for null
        if (strncmp(&str[i], "null", 4) == 0) {
            isNull[count] = 1;
            values[count] = 0;
            i += 4;
        } else {
            isNull[count] = 0;
            values[count] = atoi(&str[i]);
            // Skip the number
            if (str[i] == '-') i++;
            while (str[i] && isdigit(str[i])) i++;
        }
        count++;
    }
    
    return count;
}

struct TreeNode* buildTree(int count) {
    if (count == 0 || isNull[0]) return NULL;
    
    struct TreeNode* root = createNode(values[0]);
    static struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int index = 1;
    
    while (front < rear && index < count) {
        struct TreeNode* node = queue[front++];
        
        // Left child
        if (index < count) {
            if (!isNull[index]) {
                node->left = createNode(values[index]);
                queue[rear++] = node->left;
            }
            index++;
        }
        
        // Right child
        if (index < count) {
            if (!isNull[index]) {
                node->right = createNode(values[index]);
                queue[rear++] = node->right;
            }
            index++;
        }
    }
    
    return root;
}

int* solution(struct TreeNode* root, int* returnSize) {
    static int result[1000];
    *returnSize = 0;
    
    if (!root) return result;
    
    // Simple BFS using array as queue
    static struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    
    queue[rear++] = root;
    
    while (front < rear) {
        int levelSize = rear - front;
        
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = queue[front++];
            
            // The last node in this level is the rightmost
            if (i == levelSize - 1) {
                result[(*returnSize)++] = node->val;
            }
            
            // Add children to queue for next level
            if (node->left) queue[rear++] = node->left;
            if (node->right) queue[rear++] = node->right;
        }
    }
    
    return result;
}

int main() {
    fgets(input, sizeof(input), stdin);
    
    int count = parseArray(input);
    struct TreeNode* root = buildTree(count);
    
    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");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during level-order traversal

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w nodes where w is maximum width of tree

✓ 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

BFS Level Order Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler