level order traversal

level_order_traversal.ex

# Definition for a binary tree node.
#
# defmodule TreeNode do
#   @type t :: %__MODULE__{
#           val: integer,
#           left: TreeNode.t() | nil,
#           right: TreeNode.t() | nil
#         }
#   defstruct val: 0, left: nil, right: nil
# end

defmodule Solution do
  @spec level_order(root :: TreeNode.t | nil) :: [[integer]]
  def level_order(nil), do: []
  def level_order(%TreeNode{} = root) do
    do_level_order([root])
  end

  
  defp do_level_order(node_list, result \\ [])
  defp do_level_order([], result), do: Enum.reverse(result)
  defp do_level_order([%TreeNode{val: val} | _t] = level, result) do
    with new_result <- [[val] | result],
        legit_list <- filter_null(level) do
        do_level_order(legit_list, new_result)
    end
  end
  defp do_level_order([[%TreeNode{} | _t] = current_nodes | tail], result) do
    processed_nodes = with [head_nodes | tail_nodes] = children_nodes <- get_child_nodes(current_nodes) do
        [children_nodes]
    end
    do_level_order(tail ++ processed_nodes, [ Enum.map(current_nodes, & &1.val) | result ])
  end

  defp filter_null([%TreeNode{left: left, right: right} | t]) do
    case Enum.filter([left, right], & match?(%TreeNode{}, &1)) do
        [] -> t
        [head | tail] = list -> [list | t]
    end
  end

  defp get_child_nodes([], children), do: children
  defp get_child_nodes([%TreeNode{} = node | t], result \\ []) do
    get_child_nodes(t, result ++ get_children(node))
  end
  
  defp get_children(%TreeNode{left: nil, right: nil}), do: []
  defp get_children(%TreeNode{left: left, right: nil}), do: [left]
  defp get_children(%TreeNode{left: nil, right: right}), do: [right]
  defp get_children(%TreeNode{left: left, right: right}), do: [left, right]

end