Convert Tree to List - list

Question

everyone! I have a list type:
type ConsList<'value> =
| Cons of head: 'value * tail: ConsList<'value>
| Empty
And a tree type:
type Tree<'value> =
| Node of value: 'value * children: ConsList<Tree<'value>>
| Leaf of value: 'value
I would like a function that could collect all values in nodes and leaves of a Tree and convert them into a ConsList in order starting from the root and following from left to right.
For example, if I have: Node(1, Cons(Leaf 2, Cons(Leaf 3, Empty)))
Then I expect the output to be: Cons(1, Cons(2, Cons(3, Empty)))
I have fold-functions, if they can be useful:
let rec fold folder acc lst =
let f = fold folder
match lst with
| Empty -> acc
| Cons (hd, tl) -> f (folder acc hd) tl
let rec fold folder acc tree =
let f = fold folder
match tree with
| Leaf value -> folder acc value
| Node(value, children) -> ConsList.fold f (folder acc value) children

Answer 1

Use the tree fold to build up a list of values. Something like this:
Tree.fold (fun currentStateOfList value ->
// add value to currentStateOfList here
) initialStateOfList aTree
You need to figure out:
What is the initial state of the list?
What should be done to add a value to the current state of the list?
Depending on the requirements, you might also have to reverse the order of the list at the end.

Answer 2

If I had an n-ary tree, it might "look" something like the following.
----1--------------------
/ \ \
---2--- ---3---- --4--
/ / \ / / \ \ / \
5 6 7 8 9 10 11 12 --13--
/ \
14 15
My F# is not great, but I'm reasonably proficient in OCaml, so this type might look something like the following, if I don't define my own list type.
type 'a tree = Node of 'a | Tree of 'a * 'a tree list
Creating the above structure is then:
Tree (1,
[Tree (2, [Node 5; Node 6; Node 7]);
Tree (3, [Node 8; Node 9; Node 10; Node 11]);
Tree (4, [Node 12; Tree (13, [Node 14; Node 15])])])
To convert this to a list in a depth-first manner, and to preserve tail-recursion, a stack-based algorithm can be employed. As we iterate through, we keep a stack of tree values to evaluate in turn.
For the above example, we'd cons 1 onto a result list, then recursively call tree_to_list function on:
---2---
/ / \
5 6 7
While putting the remainder of the children on the stack.
---3---- --4--
/ / \ \ / \
8 9 10 11 12 --13--
/ \
14 15
Encountering a Node, we'd cons the value onto the result list, and store the remaining trees (boths Nodes) on the stack.
6 7 ---3---- --4--
/ / \ \ / \
8 9 10 11 12 --13--
/ \
14 15
Now we begin consuming the stack. The 6 and 7 nodes go first, then we start with the 3 Tree.
9 10 11 --4--
/ \
12 --13--
/ \
14 15
And then eventually consume the 4 Tree until we hit a Node or a Tree with no children (really the same thing) and the stack is empty. Then, because we've been building up the list backwards for efficiency, we need to reverse it.
A straightforward implementation might look like:
let tree_to_list t =
let rec tree_to_list' t a s =
match t, s with
| (Node v | Tree (v, [])), [] -> List.rev (v :: a)
| Node v, x::xs -> tree_to_list' x (v :: a) xs
| Tree (v, x::xs), _ -> tree_to_list' x (v :: a) (xs # s)
| Tree (v, []), s::ss -> tree_to_list' s (v :: a) ss
in
tree_to_list' t [] []
Given the close relation between the languages, hopefully you will find this algorithm readily applicable.