Question

I’m trying to traverse a graph with DFS.

But when I tried to pass visited node list as a function’s parameter, I found there is a problem.

When I reached at the node which has no connected node except its previous node, the recursive call ends and the information about visited nodes disappears so fall into infinite loop…

Is there an any way to keep an information about visited nodes except using imperative way?

Answer 1

Elaborating on Jeffrey’s answer, you have several different styles available. I give here only snippets that I haven’t tested, so there may be small or large mistakes.

1. You can use side-effects everywhere:

   module NodeSet = Set.Make(...)
   
   let traverse action graph_root =
     let visited = ref NodeSet.empty in
     let rec loop node =
       action node;
       visited := NodeSet.add node !visited;
       let handle child =
         if not (NodeSet.mem child !visited)
         then loop acc child in
       List.iter handle (children node)
     in loop graph_root
   

   The “visit” applies the imperative function action to all nodes in
   the graph.

2. You can store the visited node in a mutable reference, but thread
   the state of the traversal as an accumulator acc instead of
   sequencing side-effects directly. This would correspond to a use of
   the State monad.

   let traverse action init_state graph_root =
     let visited = ref NodeSet.empty in
     let rec loop acc node =
       let acc = action acc node in
       visited := NodeSet.add node !visited;
       let handle acc child =
         if NodeSet.mem child !visited
         then acc
         else loop acc child in
       List.fold_left handle acc (children node)
     in loop init_state graph_root
   

3. You can reuse this state-passing logic to also pass the visited
   node information.

   let traverse action init_state graph_root =
     let rec loop acc visited node =
       let acc = action acc node in
       let visited = NodeSet.add node visited in
       let handle (acc, visited) child =
         if NodeSet.mem child !visited
         then (acc, visited)
         else loop acc visited child in
       List.fold_left handle (acc, visited) (children node)
     in loop init_state NodeSet.empty graph_root
   

4. Finally, you can move to a tail-recursive traversal by passing
   information about which nodes should be computed next in the first
   recursive call. This corresponds to a general transformation into
   Continuation Passing Style, but with a domain-specific representation
   of continuations (simply nodes to visit).

   let traverse action init_state graph_root =
     let rec loop acc visited = function
       | [] -> acc
       | node::to_visit ->
          if NodeSet.mem node visited then loop acc visited to_visit
          else begin
            let acc = action acc node in
            let visited = NodeSet.add node visited in
            let to_visit = children node @ to_visit in
            loop acc visited to_visit
          end
     in loop NodeSet.empty init_state [graph_root]
   

   Jeffrey remarks that with this presentation, you can change the
   traversal order from DFS to BFS by simply changing the way to_visit
   is updated, adding children nodes to the end of the sequence rather
   than at the beginning (which requires a queue structure to be
   algorithmically efficient).