Algorithms: Tree Algorithms

int tree_preorder(const std::vector<int>& left_child, const std::vector<int>& right_child, int root, std::vector<int>& output) {
    alg_require(left_child.size() <= 1000000);
    alg_require(right_child.size() <= 1000000);
    alg_require(output.size() <= 1000000);
    int n = (int)left_child.size();
    alg_require(((n >= 0) && (n <= 1000000)));
    alg_require(((int)left_child.size() == n));
    alg_require(((int)right_child.size() == n));
    alg_require(((int)output.size() == n));
    alg_require(((root >= alg_sub(0, 1)) && (root < n)));
    for (int alg_i = 0; alg_i < (int)left_child.size(); alg_i++) {
        int alg_value = left_child[alg_i];

    static int tree_preorder(ReadOnlySpan<int> left_child, ReadOnlySpan<int> right_child, int root, Span<int> output) {
        checked {
            int n = left_child.Length;
            alg_require(((n >= 0) && (n <= 1000000)));
            alg_require((left_child.Length == n));
            alg_require((right_child.Length == n));
            alg_require((output.Length == n));
            alg_require(((root >= (-1)) && (root < n)));
            for (int alg_i = 0; alg_i < left_child.Length; alg_i++) {
                int alg_value = left_child[alg_i];
                alg_require(((alg_value >= (-1)) && (alg_value < n)));
            }

function tree_preorder(array $left_child, array $right_child, int $root, array &$output): int {
    alg_require(array_is_list($left_child));
    alg_require(array_is_list($right_child));
    alg_require(array_is_list($output));
    $n = count($left_child);
    alg_require((($n >= 0) && ($n <= 1000000)));
    alg_require((count($left_child) == $n));
    alg_require((count($right_child) == $n));
    alg_require((count($output) == $n));
    alg_require((($root >= alg_sub(0, 1)) && ($root < $n)));
    for ($alg_i = 0; $alg_i < count($left_child); $alg_i++) {
        $alg_value = $left_child[$alg_i];