Вид справа

/**
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

public class Solution
{
    private static void Preorder(TreeNode node, int level, List<int> output)
    {
        if (node == null)
        {
            return;
        }

        // запоминаем последнюю вершину для текущего уровня
        // старая вершина будет перетерта новой (той, что находится правее)
        if (output.Count == level)
        {
            output.Add(node.val);
        }
        output[level] = node.val;

        // обходим левое и правое поддерево
        Preorder(node.left, level + 1, output);
        Preorder(node.right, level + 1, output);
    }

    public static List<int> RightSideView(TreeNode root)
    {
        var output = new List<int>();
        Preorder(root, 0, output);
        return output;
    }
}

#include <vector>

using namespace std;

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

void preorder(TreeNode* node, int level, vector<int>& output) {
    if (node == nullptr) {
        return;
    }

    // запоминаем последнюю вершину для текущего уровня
    // старая вершина будет перетерта новой (той, что находится правее)
    if (output.size() == level) {
        output.push_back(node->val);
    }
    output[level] = node->val;

    // обходим левое и правое поддерево
    preorder(node->left, level + 1, output);
    preorder(node->right, level + 1, output);
}

vector<int> rightSideView(TreeNode* root) {
    vector<int> output;
    preorder(root, 0, output);
    return output;
}

package main

// type TreeNode struct {
//     Val int
//     Left *TreeNode
//     Right *TreeNode
// }

func preorder(node *TreeNode, level int, result *[]int) {
    if node == nil {
        return
    }

    // запоминаем последнюю вершину для текущего уровня
    // старая вершина будет перетерта новой (той, что находится правее)
    if level == len(*result) {
        *result = append(*result, node.Val)
    }
    (*result)[level] = node.Val

    preorder(node.Left, level + 1, result)
    preorder(node.Right, level + 1, result)
}

func rightSideView(root *TreeNode) []int {
    result := make([]int, 0)
    preorder(root, 0, &result)
    return result
}

import java.util.*;

// class TreeNode {
//     int val;
//     TreeNode left, right;
//     public TreeNode(int value) {
//         this.val = value;
//         this.left = this.right = null;
//     }
// }

class Solution {
    private void preorder(TreeNode node, Integer level, List<Integer> result) {
        if (node == null) {
            return;
        }

        // запоминаем последнюю вершину для текущего уровня
        // старая вершина будет перетерта новой (той, что находится правее)
        if (result.size() == level) {
            result.add(node.val);
        }
        result.set(level, node.val);

        // обходим левое и правое поддерево
        preorder(node.left, level + 1, result);
        preorder(node.right, level + 1, result);
    }

    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        preorder(root, 0, result);
        return result;
    }
}

from typing import *

# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

def preorder(node: TreeNode, level: int, result: List[int]):
    if node is None:
        return

    # запоминаем последнюю вершину для текущего уровня
    # старая вершина будет перетерта новой (той, что находится правее)
    if level == len(result):
        result.append(0)
    result[level] = node.val

    preorder(node.left, level + 1, result)
    preorder(node.right, level + 1, result)

def right_side_view(root: TreeNode) -> List[int]:
    result = []
    preorder(root, 0, result)
    return result

import { TreeNode } from './treeNode.js';

/**
 * class TreeNode {
 *     constructor(val, left, right) {
 *         this.val = val;
 *         this.left = (left === undefined ? null : left);
 *         this.right = (right === undefined ? null : right);
 *     }
 * }
 */

export function preorder(node, level, output) {
    if (node === null) {
        return;
    }

    // запоминаем последнюю вершину для текущего уровня
    // старая вершина будет перетерта новой (той, что находится правее)
    if (output.length === level) {
        output.push(node.val);
    }
    output[level] = node.val;

    // обходим левое и правое поддерево
    preorder(node.left, level + 1, output);
    preorder(node.right, level + 1, output);
}

export function rightSideView(root) {
    const output = [];
    preorder(root, 0, output);
    return output;
}