Tree traversal in elixir, pre-order, in-order, post-order What am I doing wrong?

Hello and welcome,

I did not read all the code, but this is not working as You expect, it should be an element first, then a list. If needed, You can reverse the list at the end.

[node.data | nodes]

Remember a list is [head | tail], with head being an element pushed at the head, while tails is a list.

What output would you expect instead?

You don’t use the return values of th recursive calls, they won’t have any effect besides heating your room.

Hi. Thanks.

I have edited the section of the code that way but still not working.

What does “not working” mean? Do you get an error, if yes which? Is the output different from what you expect, if yes how?

And how does your current code look like?

I expect the function to return a list after completing the traversal

defmodule Algos do
    #pre_order function, prints the root, the left then the right
    def pre_order(node, nodes) do
        next = [node.data | nodes]
        if (node && node.left) do
            Algos.pre_order(node.left, next) 
        end
        if (node && node.right) do
            Algos.pre_order(node.right, next)
        end
        next
    end

    #in_order function, prints the left, the root then the right
    def in_order(node, nodes) do
        if (node && node.left) do 
            Algos.in_order(node.left, nodes) 
        end
        next = [node.data | nodes]
        if (node && node.right) do
            Algos.in_order(node.right, next)
        end
        next
    end

    #post_order function, prints the left, the right then the root
    def post_order(node, nodes) do
        if (node && node.left) do
            Algos.post_order(node.left, nodes)
        end
        if (node && node.right) do
            Algos.post_order(node.right, nodes)
        end
        [node.data | nodes]
    end
end

defmodule Traverse do
    def print do
        root = %{
            data: "A",
            left: %{
                data: "B", 
                left: %{
                    data: "C", 
                    left: nil,
                    right: nil
                },
                right: %{
                    data: "D",
                    left: nil, 
                    right: nil
                }
            },
            right: %{
                data: "E", 
                left: nil, 
                right: nil
            }
        }

        result = Algos.pre_order(root, [])
        IO.puts(result)

        result2 = Algos.in_order(root, [])
        IO.puts(result2)

        result3 = Algos.post_order(root, [])
        IO.puts(result3)
    end
end

Traverse.print

That is the current code.

I still get only the first node “A” returned by each function.

[Running] elixir "/Volumes/MAC/d/Algorithms/tree_traversal.exs"
A
A
A

[Done] exited with code=0 in 3.304 seconds

I expect the functions to traverse the tree, create a list, and then return that list

You are not using the return values of the recursive calls. They do not have an effect.

What would be the best way to return the list after completing the recursive calls?
…

I’m still struggling to understand Elixir

You already return it. Though you are not using the returned list.

Have you been able to make any progress?

You “liked” my previous post, so I can assume you read it. If you have any problems understanding the hints, please feel free to ask more questions.