Right Side View of Binary Tree in DSA C++ - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Right Side View for a Simple Binary Tree

What is the output of the right side view function for the given binary tree?

DSA C++

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

#include <vector>
#include <queue>
#include <iostream>

std::vector<int> rightSideView(TreeNode* root) {
    std::vector<int> result;
    if (!root) return result;
    std::queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        int size = q.size();
        for (int i = 0; i < size; ++i) {
            TreeNode* node = q.front();
            q.pop();
            if (i == size - 1) result.push_back(node->val);
            if (node->left) q.push(node->left);
            if (node->right) q.push(node->right);
        }
    }
    return result;
}

// Tree structure:
//       1
//      / \
//     2   3
//      \   \
//       5   4

int main() {
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->right = new TreeNode(5);
    root->right->right = new TreeNode(4);

    std::vector<int> output = rightSideView(root);
    for (int val : output) {
        std::cout << val << " ";
    }
    return 0;
}

A [1, 3, 4]

B [1, 2, 5]

C [1, 3, 5]

D [1, 2, 4]

💡 Hint

Think about which nodes are visible when looking from the right side level by level.

The right side view shows the last node at each level when traversed from left to right. At level 1, node 1 is visible; at level 2, node 3; at level 3, node 4.

🧠 Conceptual

intermediate

Understanding the Right Side View Algorithm

Which of the following best describes the approach used to find the right side view of a binary tree?

A Traverse the tree level by level and record the last node at each level.

B Traverse the tree level by level and record the first node at each level.

C Traverse the tree in preorder and record all right children.

D Traverse the tree in inorder and record nodes with no left child.

💡 Hint

Consider which node is visible from the right side at each level.

The right side view is obtained by recording the last node visited at each level during a level order traversal.

🔧 Debug

advanced

Identify the Error in Right Side View Implementation

What error will occur when running the following code snippet for right side view?

DSA C++

std::vector<int> rightSideView(TreeNode* root) {
    std::vector<int> result;
    std::queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        int size = q.size();
        for (int i = 0; i <= size; ++i) {
            TreeNode* node = q.front();
            q.pop();
            if (i == size - 1) result.push_back(node->val);
            if (node->left) q.push(node->left);
            if (node->right) q.push(node->right);
        }
    }
    return result;
}

A Logic error: returns empty vector

B Runtime error due to popping from empty queue

C Compilation error due to missing semicolon

D No error, returns correct output

💡 Hint

Check the loop boundary condition carefully.

The for loop uses i <= size which causes one extra iteration, leading to popping from an empty queue and runtime error.

❓ Predict Output

advanced

Output of Right Side View for Left-Skewed Tree

What is the output of the right side view function for this left-skewed binary tree?

DSA C++

// Tree structure:
//     1
//    /
//   2
//  /
// 3
//
#include <iostream>
#include <vector>
#include <queue>

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

std::vector<int> rightSideView(TreeNode* root) {
    std::vector<int> result;
    if (!root) return result;
    std::queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        int size = q.size();
        for (int i = 0; i < size; ++i) {
            TreeNode* node = q.front();
            q.pop();
            if (i == size - 1) result.push_back(node->val);
            if (node->left) q.push(node->left);
            if (node->right) q.push(node->right);
        }
    }
    return result;
}

int main() {
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->left->left = new TreeNode(3);

    std::vector<int> output = rightSideView(root);
    for (int val : output) {
        std::cout << val << " ";
    }
    return 0;
}

A [3]

B [1, 3]

C [1]

D [1, 2, 3]

💡 Hint

Even if the tree is left-skewed, the right side view shows the rightmost node at each level.

Since there are no right children, the right side view shows the only node at each level: 1, then 2, then 3.

🚀 Application

expert

Number of Nodes in Right Side View for Complete Binary Tree

Given a complete binary tree of height h (root at height 1), how many nodes will the right side view contain?

A h - 1

B 2^h - 1

C h

D 2^(h-1)

💡 Hint

Right side view shows one node per level.

The right side view contains exactly one node per level, so for height h, it contains h nodes.