visiting each node - algorithm

Question

I have a hobby project which is about creating a tree to store identification numbers. I had used digit, stored at node, that is node can be 0 1 2 3 4 5 6 7 8 9.
After I have create tree, I want compose list from tree. But, I could not find a algorithm to manage my goal.
What I want :
"recompose tree" will return list of numbers. For below tree it should be
[ 2, 21, 243, 245, 246, 78, 789 ]
Root
/ \
2* 7
/ \ \
1* 4 8*
/ \ \ \
3* 5* 6* 9*
my data type : data ID x = ID ( ( x, Mark ), [ ID x ] )
data Mark = Marked | Unmarked
EDIT:
for convenience : * shows it is marked
I have stored digit as char, actually not 1,
it is stored as'1'
Do you have advice how I can do that ? ( advice is prefferred to be algorithm )

Answer 1

What about
recompose :: Num a => ID a -> [a]
recompose = go 0
where
go acc (ID ((n, Marked), ids)) =
let acc' = 10 * acc + n
in acc' : concatMap (go acc') ids
go acc (ID ((n, Unmarked), ids)) =
let acc' = 10 * acc + n
in concatMap (go acc') ids
?
That is, we traverse the tree while accumulating a value for the path from the root to a node. At every node we update the accumulator by multiplying the value for the path by 10 and adding the value for the node to it. The traversal produces a list of all accumulator values for marked node: so, at marked node we add the accumulator value to the list, for unmarked nodes we just propagate the list that we have collected for the children of the node.
How do we compute the list for the children of a node? We recursively call the traversal function (go) to all children by mapping it over the list of children. That gives us a list of lists that we concatenate to obtain a single list. (concatMap f xs is just concat (map f xs)) or concat . map f.)
In attribute-grammar terminology: the accumulator serves as an inherited attribute, while the returned list is a synthesised attribute.
As a refinement, we can introduce an auxiliary function isMarked,
isMarked :: Mark -> Bool
isMarked Marked = True
isMarked Unmarked = False
so that we can concisely write
recompose :: Num a => ID a -> [a]
recompose = go 0
where
go acc (ID ((n, m), ids)) =
let acc' = 10 * acc + n
prefix = if isMarked m then (acc' :) else id
in prefix (concatMap (go acc') ids)

Answer 2

BTW: this can even be done in sql:
DROP SCHEMA tmp CASCADE;
CREATE SCHEMA tmp ;
SET search_path='tmp';
CREATE TABLE the_tree
( id CHAR(1) NOT NULL PRIMARY KEY
, parent_id CHAR(1) REFERENCES the_tree(id)
);
INSERT INTO the_tree(id,parent_id) VALUES
( '#', NULL)
,( '2', '#')
,( '7', '#')
,( '1', '2')
,( '4', '2')
,( '3', '4')
,( '5', '4')
,( '6', '4')
,( '8', '7')
,( '9', '8')
;
WITH RECURSIVE sub AS (
SELECT id, parent_id, ''::text AS path
FROM the_tree t0
WHERE id = '#'
UNION
SELECT t1.id, t1.parent_id, sub.path || t1.id::text
FROM the_tree t1
JOIN sub ON sub.id = t1.parent_id
)
SELECT sub.id,sub.path
FROM sub
ORDER BY path
;
RESULT: (postgresql)
NOTICE: drop cascades to table tmp.the_tree
DROP SCHEMA
CREATE SCHEMA
SET
NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "the_tree_pkey" for table "the_tree"
CREATE TABLE
INSERT 0 10
id | path
----+------
# |
2 | 2
1 | 21
4 | 24
3 | 243
5 | 245
6 | 246
7 | 7
8 | 78
9 | 789
(10 rows)