Binary Tree Paths

class Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> out;
        function<void(TreeNode*, string)> dfs = [&](TreeNode* n, string path) {
            if (!n) return;
            if (!path.empty()) path += "->";
            path += to_string(n->val);
            if (!n->left && !n->right) { out.push_back(path); return; }
            dfs(n->left, path);
            dfs(n->right, path);
        };
        dfs(root, "");
        return out;
    }
};

func binaryTreePaths(root *TreeNode) []string {
    out := []string{}
    var dfs func(n *TreeNode, path string)
    dfs = func(n *TreeNode, path string) {
        if n == nil {
            return
        }
        if path != "" {
            path += "->"
        }
        path += strconv.Itoa(n.Val)
        if n.Left == nil && n.Right == nil {
            out = append(out, path)
            return
        }
        dfs(n.Left, path)
        dfs(n.Right, path)
    }
    dfs(root, "")
    return out
}

from typing import List, Optional

class Solution:
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        out: List[str] = []

        def dfs(n: Optional[TreeNode], path: str) -> None:
            if not n:
                return
            if path:
                path += "->"
            path += str(n.val)
            if not n.left and not n.right:
                out.append(path)
                return
            dfs(n.left, path)
            dfs(n.right, path)

        dfs(root, "")
        return out

var binaryTreePaths = function(root) {
    const out = [];
    const dfs = (n, path) => {
        if (!n) return;
        if (path !== "") path += "->";
        path += String(n.val);
        if (!n.left && !n.right) {
            out.push(path);
            return;
        }
        dfs(n.left, path);
        dfs(n.right, path);
    };
    dfs(root, "");
    return out;
};

class Solution {
    private List<String> out;

    private void dfs(TreeNode n, String path) {
        if (n == null) return;
        if (!path.isEmpty()) path += "->";
        path += n.val;
        if (n.left == null && n.right == null) {
            out.add(path);
            return;
        }
        dfs(n.left, path);
        dfs(n.right, path);
    }

    public List<String> binaryTreePaths(TreeNode root) {
        out = new ArrayList<>();
        dfs(root, "");
        return out;
    }
}

function binaryTreePaths(root: TreeNode | null): string[] {
    const out: string[] = [];
    const dfs = (n: TreeNode | null, path: string): void => {
        if (!n) return;
        if (path !== "") path += "->";
        path += String(n.val);
        if (!n.left && !n.right) {
            out.push(path);
            return;
        }
        dfs(n.left, path);
        dfs(n.right, path);
    };
    dfs(root, "");
    return out;
}