LeetCode 102. Binary Tree Level Order Traversal in F#

URL

leetcode.com/problems/binary-tree-level-ord..

Code

github.com/syohex/dotnet-study/blob/master/..

type Tree =
    | Leaf
    | Node of int * Tree * Tree

    static member value(t: Tree) =
        match t with
        | Leaf -> failwith "never reach here"
        | Node (v, _, _) -> v

    static member isNode(t: Tree) =
        match t with
        | Node (_) -> true
        | Leaf -> false

let levelOrder (root: Tree) : int list list =
    let rec levelOrder' nodes acc =
        match nodes with
        | [] -> acc |> List.rev
        | _ ->
            let vals =
                nodes
                |> List.fold (fun acc n -> (Tree.value n) :: acc) []
                |> List.rev

            let nodes' =
                nodes
                |> List.fold
                    (fun acc n ->
                        match n with
                        | Node (_, left, right) -> right :: left :: acc
                        | Leaf -> failwith "never reach here")
                    []
                |> List.filter Tree.isNode
                |> List.rev

            levelOrder' nodes' (vals :: acc)

    match root with
    | Leaf -> []
    | _ -> levelOrder' [ root ] []