Binary Tree Right Side View

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> ans;
        function<void(TreeNode*, int)> dfs = [&](TreeNode* u, int depth) {
            if (!u) return;
            if ((int)ans.size() == depth) ans.push_back(u->val);
            dfs(u->right, depth + 1);
            dfs(u->left, depth + 1);
        };
        dfs(root, 0);
        return ans;
    }
};

func rightSideView(root *TreeNode) []int {
    ans := []int{}
    var dfs func(u *TreeNode, depth int)
    dfs = func(u *TreeNode, depth int) {
        if u == nil {
            return
        }
        if len(ans) == depth {
            ans = append(ans, u.Val)
        }
        dfs(u.Right, depth+1)
        dfs(u.Left, depth+1)
    }
    dfs(root, 0)
    return ans
}

from typing import List, Optional

class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        ans: List[int] = []

        def dfs(u: Optional[TreeNode], depth: int) -> None:
            if not u:
                return
            if len(ans) == depth:
                ans.append(u.val)
            dfs(u.right, depth + 1)
            dfs(u.left, depth + 1)

        dfs(root, 0)
        return ans

var rightSideView = function(root) {
    const ans = [];
    const dfs = (u, depth) => {
        if (!u) return;
        if (ans.length === depth) ans.push(u.val);
        dfs(u.right, depth + 1);
        dfs(u.left, depth + 1);
    };
    dfs(root, 0);
    return ans;
};

class Solution {
    private List<Integer> ans = new ArrayList<>();

    public List<Integer> rightSideView(TreeNode root) {
        dfs(root, 0);
        return ans;
    }

    private void dfs(TreeNode u, int depth) {
        if (u == null) return;
        if (ans.size() == depth) ans.add(u.val);
        dfs(u.right, depth + 1);
        dfs(u.left, depth + 1);
    }
}

function rightSideView(root: TreeNode | null): number[] {
    const ans: number[] = [];
    const dfs = (u: TreeNode | null, depth: number): void => {
        if (!u) return;
        if (ans.length === depth) ans.push(u.val);
        dfs(u.right, depth + 1);
        dfs(u.left, depth + 1);
    };
    dfs(root, 0);
    return ans;
}