解释递归树遍历的最佳UML图是什么？

Question

I want to explain my C# code which traverses a parse tree for code analysis. It is similar to the following but longer:

    private void traverse(ParseTreeNode node)
    {
        if (node.ChildNodes.Count == 0)
        {
            return;
        }

        switch (node.Term.Name.ToUpper())
        {
            case "FILE":
                traverse(node.ChildNodes[0]);
                return;

            case "PROGRAM":
                traverse(node.ChildNodes[0]);
                return;

            //etc.
        }
    }

What is the most appropriate UML diagram for showing this? Thanks

Answer 1

Since you are explaining behavior of the tree traversal, not structure of the tree, your choices are limited to Behavior Diagrams . Since you wish to show what happens inside a method, your choices are further narrowed down to Interaction Diagrams .

At this point, you need to choose between a Sequence Diagram and a Collaboration Diagram . Both diagram types could be used to show a tree traversal. The main difference is in how the method calls are going to be shown. In the sequence diagram you would show invocations with horizontal lines going across the "swim lanes", while the collaboration diagram will distinguish the calls using numbers.

Since this is recursion, you would be showing multiple calls to the method with the same name. This gives advantage to sequence diagrams, because the readers would not need to check the numbering to see whose traverse method you are calling. That is why I would use a sequence diagram..

When I draw sequence diagrams showing recursive interaction, I build a small object graph on a piece of paper, and then draw out the interactions of the recursive method.

EDIT : Here is why I would not use an Activity Diagram ^* to show a sequence of recursive calls. Despite a note in the comment suggesting to use an Activity Diagram for this, I think this is not a good idea: activity diagrams are good at capturing algorithms happening within the same object, while here we deal with an algorithm that spawns multiple objects.

^* Which is a glorified flowchart, a notoriously poor mechanism for capturing the essence of recursive algorithms.

Answer 2

Continuing the discussion arisen in the comments after dasblinkenlight's answer, I suggest the following activity diagram as a solution:

Activity diagram puts an emphasis on the sequence of steps in a process/algorithm, decisions made on the way, manipulated data and calculations, eventually concurrent tasks, invocations, etc.

There is always some kind of context to activity diagram. In this case it is a method traverse().