# Leetcode Binary Tree Right Side View problem solution

In this Leetcode Binary Tree Right Side View problem solution we have 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.

## Problem solution in Python.

```class Solution:
def rightSideView(self, root: TreeNode) -> List[int]:
if not root:
return []

q = [root]
res = []
while q:
n = len(q)
for i in range(n):
popped = q.pop(0)
if popped.left:
q.append(popped.left)
if popped.right:
q.append(popped.right)
if i == n - 1:
res.append(popped.val)
return res
```

## Problem solution in Java.

```public class Solution {
public List<Integer> rightSideView(TreeNode root) {
List<Integer> result = new ArrayList<Integer>();
if(root==null) return result;
while(q.size()>0){
int size = q.size();
for(int i=0;i<size;i++){
TreeNode node= q.poll();
if(i==size-1)
}
}
return result;
}
}
```

## Problem solution in C++.

```class Solution {
int mxl=-1;
public:
vector<int> rightSideView(TreeNode* root) {
vector<int> ans;
dfs(root,ans,0);
return ans;
}

void dfs(TreeNode* root, vector<int>& ans,int level)
{
if(root==nullptr) return;
if(mxl<level)
{
ans.push_back(root->val);
mxl = level;
}
dfs(root->right,ans,level+1);
dfs(root->left,ans,level+1);
}
};
```

## Problem solution in C.

```int* rightSideView(struct TreeNode* root, int* returnSize){
struct TreeNode *n[128] = { root };
int *a = malloc(sizeof(int [100])), k = 0;
for (int f = 0, b = 1, lb ; root && f < b ; a[k++] = n[lb - 1]->val)
for (lb = b ; f < lb && b < 128 ; (n[b++] = n[f]->left) || b--, (n[b++] = n[f++]->right) || b--);
return *returnSize = k, a;
}
```