递归树映射

Question

我最近一直在研究树的实现以及我们如何表示和理解树。我的重点是将数学表达式转换为二叉树，我设置了以线性形式（例如字符串或数组）表示树的问题，同时仍然保留有关树及其子树的重要信息。

因此，我为二进制表达式树开发了一种非常简单的编码，就是这样做的。然而，我在递归庄园中有效地实现它时遇到了一些问题，这似乎是这个概念背后的一个失败的方面。

如果节点作为左子节点，则编码很简单，如果它作为右子节点，则给出 1 的映射。这种简单的编码允许我对整个平衡和不平衡树进行编码，如下所示：

           ##                      ##
          /  \                    /  \
         1    0         OR       1    0
        / \  / \                     / \
       11 10 01 00                  01  00 

Etc to trees深度 N

有没有人对如何创建一个递归函数有任何建议，该函数将创建表示此类映射的前缀字符串（例如 ## 1 11 10 0 01 00）。

有人告诉我，这很困难/不可能，因为必须跟踪 1 和 0 之间的交替，同时保留并连接到父级的值。

我想知道是否有人对如何使用 C# 做到这一点有任何见解或想法？

Answer 1

我不确定我是否理解你的问题，但这里有一些可能有帮助的东西。一种解决方案可能是在图上实现图遍历例程（请记住树是专门的图），其中访问发生在您第一次遇到节点/顶点时。当您要求使用 C# 时，我为发布 Java 代码表示歉意，但我碰巧知道 Java...

public void depthFirstSearch(Graph graph, Vertex start){
    Set<Vertex> visited = new HashSet<Vertex>(); // could use vertex.isVisited()...
    Deque<Vertex> stack = new ArrayDeque<Vertex>(); // stack implies depth first

    // first visit the root element, then add it to the stack so
    // we will visit it's children in a depth first order
    visit(start);
    visited.add(start);
    stack.push(start);   

    while(stack.isEmpty() == false){
        List<Edge> edges = graph.getEdges(stack.peekFirst());
        Vertex nextUnvisited = null;
        for(Edge edge : edges){
            if(visited.contains(edge.getEndVertex)) == false){
               nextUnvisited = edge.getEndVertex();
               break; // break for loop
            }
        }
        if(nextUnvisited == null){
            // check the next item in the stack
            Vertex popped = stack.pop();
        } else {
            // visit adjacent unvisited vertex
            visit(nextUnvisited);
            visited.add(nextUnvisited);
            stack.push(nextUnvisited); // visit it's "children"
        }
    }
}

public void visit(Vertex vertex){
    // your own visit logic (string append, etc)
}

您可以通过使用 Deque 作为队列而不是堆栈来轻松地将其修改为广度优先搜索，如下所示：

stack.pop()  >>>>  queue.removeFirst()
stack.push() >>>>  queue.addLast()

请注意，为此目的，图和 Edge 类支持以下操作：

public interface Graph {
    ...
    // get edges originating from Vertex v
    public List<Edge> getEdges(Vertex v);
    ...
}

public interface Edge {
    ...
    // get the vertex at the start of the edge
    // not used here but kind of implied by the getEndVertex()...
    public Vertex getStartVertex();
    // get the vertex at the end of the edge
    public Vertex getEndVertex();
    ...
}

希望这能给您一些想法。

Answer 2

好吧，我不知道我是否完全明白你的问题，但似乎你想要对树进行预序遍历。我不知道 c# 的语法，但我认为伪代码如下：

preorder_traversal(node)
    if(node != NULL)
        print(node)
        preorder_traversal(left_sub_child)
        preorder_traversal(right_sub_child)
    else
        return

Answer 3

即使对于经验丰富的程序员来说，递归地构建一棵树也是一个艰巨的挑战。我意识到我在这个问题上有点晚了，考虑到它最初是在 2011 年 3 月发布的。迟到总比不做好？

创建树的一个重要因素是确保数据集的格式正确。您只需要一种将父级与子级关联起来的方法。一旦明确定义了关联，您就可以开始编写解决方案。我选择使用像这样的简单格式：

ParentId ChildId
1        2
1        3
2        4
3        5

等等。

一旦建立了这种关系，我开发了一种递归方法来迭代数据集来构建树。

首先，我识别所有父节点并将它们存储在一个集合中，使用父 ID 和子 ID 的组合为每个节点提供唯一标识符：

 private void IdentifyParentNodes()
{
    SortedList<string, MyTreeNode> newParentNodes = new SortedList<string,MyTreeNode>();
    Dictionary<string, string> parents = new Dictionary<string, string>();
    foreach (MyTreeNode oParent in MyTreeDataSource.Values)
    {
        if (!parents.ContainsValue(oParent.ParentId))
        {
            parents.Add(oParent.ParentId + "." + oParent.ChildId, oParent.ParentId);

            newParentNodes.Add(oParent.ParentId + "." + oParent.ChildId, oParent);
        }
    }

    this._parentNodes = newParentNodes;
}

然后根调用方法将循环遍历父节点并调用递归方法来构建树：

// Build the rest of the tree
foreach (MyTreeNode node in ParentNodes.Values)
{
    RecursivelyBuildTree(node);
}

递归方法：

private void RecursivelyBuildTree(MyTreeNode node)
{
    int nodePosition = 0;

    _renderedTree.Append(FormatNode(MyTreeNodeType.Parent, node, 0));
    _renderedTree.Append(NodeContainer("open", node.ParentId));

    foreach (MyTreeNode child in GetChildren(node.ParentId).Values)
    {
        nodePosition++;
        if (IsParent(child.ChildId))
        {
            RecursivelyBuildTree(child);
        }
        else
        {
            _renderedTree.Append(FormatNode(MyTreeNodeType.Leaf, child, nodePosition));
        }
    }
    _renderedTree.Append(NodeContainer("close", node.ParentId));
}

用于获取父级的子级的方法：

private SortedList<string, MyTreeNode> GetChildren(string parentId)
{
    SortedList<string, MyTreeNode> childNodes = new SortedList<string, MyTreeNode>();
    foreach (MyTreeNode node in this.MyTreeDataSource.Values)
    {
        if (node.ParentId == parentId)
        {
            childNodes.Add(node.ParentId + node.ChildId, node);
        }
    }
    return childNodes;
}

不是那么复杂或优雅，但它完成了工作。这是在 2007 年编写的，所以它是旧代码，但它仍然有效。 :-) 希望这有帮助。