高效搜索树结构中的所有节点

Question

我正在使用由单个“根”TreeNodeDefinition 记录组成的树型结构，该记录可以包含其他 TreeNodeDefinition 类的列表，然后每个类都可以包含进一步的列表等等。

我基本上希望能够遍历树结构中的所有节点并检查每个节点是否满足条件，然后将该定义记录添加到列表中。我想出了一种方法来做到这一点，但我不禁认为有一种更有效的方法：

List<ITreeNodeDefinition> treeNodeDefinitions = new List<ITreeNodeDefinition>();

treeNodeDefinitions = treeFactory.SearchNodesByRelationshipId(treeNodeDefinition, relationshipId, new List<ITreeNodeDefinition>());

第一个参数是我的根节点定义记录，第二个参数是我需要比较每个节点的参数，最后我传入一个空列表，每次节点匹配我的检查时我想要填充该列表。方法如下：

    public List<ITreeNodeDefinition> SearchNodesByRelationshipId(ITreeNodeDefinition treeNodeDefinition, int? relationshipId, List<ITreeNodeDefinition> tndList)
    {
        if (treeNodeDefinition.RelationshipId == relationshipId)
        {
            tndList.Add(treeNodeDefinition);
        }

        if (treeNodeDefinition.Nodes.Count != 0)
        {
            foreach (ITreeNodeDefinition nodeDefinition in treeNodeDefinition.Nodes)
            {
                List<ITreeNodeDefinition> tempTable = this.SearchNodesByRelationshipId(nodeDefinition, relationshipId, tndList);
            }
        }
        return tndList;
    }

如您所见，该方法为在 treeNodeDefinition.Nodes 列表中找到的每个子节点调用自身。这回到了一个我从不做任何事情的临时表......这对我来说效率低下。我想知道是否有更直接的方式来导航这种结构......我确定我只是错过了一个技巧。

Answer 1

您可以使用显式堆栈来解决此问题并完全避免递归：

public static IEnumerable<ITreeNodeDefinition> DepthFirstSearch(ITreeNodeDefinition root, int? relationshipId)
{
    var stack = new Stack<ITreeNodeDefinition>();
    stack.Push(root);
    while(stack.Count > 0)
    {
        var current = stack.Pop();
        if (current.RelationshipId == relationshipId)
            yield return current;

        foreach(var node in current.Nodes)
            stack.Push(node);
    }
}

不过，要补充这一点，在关系 id 检查中根本不进行硬编码可能会更简单、更灵活，如果你发现你经常尝试遍历树结构，只需在之后过滤结果：

var matches = treeFactory.Traverse(root)
                         .Where(t => t.RelationshipId == 5)
                         .ToList();

对此进行扩展，通过使用搜索谓词，您可以像 LINQ 一样将此搜索功能构建到方法中，您可以像这样实现：

public static IEnumerable<ITreeNodeDefinition> DepthFirstSearch(ITreeNodeDefinition root, Func<ITreeNodeDefinition, bool> predicate)
{
    var stack = new Stack<ITreeNodeDefinition>();
    stack.Push(root);
    while (stack.Count > 0)
    {
        var current = stack.Pop();
        if (predicate(current))
            yield return current;

        foreach (var node in current.Nodes)
            stack.Push(node);
    }
}

这样做的好处是您在遍历时不会在一个特定的搜索案例中进行硬编码。使用 RelationshipId 搜索调用它是：

var matches = treeFactory.DepthFirstSearch(root, t => t.RelationshipId == 5)
                         .ToList();

为完整起见，以下是广度优先搜索的示例。请注意 Queue<T> 与 Stack<T> 在遍历顺序如何变化方面的区别：

public static IEnumerable<ITreeNodeDefinition> BreadthFirstSearch(ITreeNodeDefinition root, Func<ITreeNodeDefinition, bool> predicate)
{
    var queue = new Queue<ITreeNodeDefinition>();
    queue.Enqueue(root);
    while (queue.Count > 0)
    {
        var current = queue.Dequeue();
        if (predicate(current))
            yield return current;

        foreach (var node in current.Nodes)
            queue.Enqueue(node);
    }
}

对于您的用例，除了广度优先以在列出节点时通常更好的方式排序之外，任何一个都可能没有优势。

Answer 2

查看问题/代码，我认为问题与一件事无关（如您所说的冗余 tempTable 变量），而是与多个领域有关，我将尝试突出显示这些领域/问题。

1) 理论。在迭代树之前您需要知道的第一件事 - 有 2 种迭代树的方法“广度优先”和“深度优先'。它们可以通过'recursion'和'loop'来实现。有很多关于它的文章。

我建议你阅读一些关于这些方法的文章，其中一些：

• Recursion vs loops
• https://github.com/tinkerpop/gremlin/wiki/Depth-First-vs.-Breadth-First

2) 您从性能方面注意到的问题。是的，当您说将先前调用的结果存储到“tempTable”中不是很好时，您是对的。返回“tempTable”对性能或内存没有太大影响，因为“tempTamble”与“tndList”引用了相同的对象。返回方法参数不会带来“效率低下”。它影响的唯一一件事是 - 不干净的代码和堆栈中的几个字节。真的，你不需要在你的方法中返回任何东西。为什么要返回列表？

我建议你阅读关于值和引用类型。一些材料

• https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/reference-types
• https://www.infoworld.com/article/3043992/application-development/a-deep-dive-value-and-reference-types-in-net.html

我稍微修改了你的代码，现在它返回 void：

public void SearchNodesByRelationshipId(ITreeNodeDefinition treeNodeDefinition, int? relationshipId, List<ITreeNodeDefinition> tndList)
{
    if (treeNodeDefinition.RelationshipId == relationshipId)
    {
        tndList.Add(treeNodeDefinition);
    }

    if (treeNodeDefinition.Nodes.Count != 0)
    {
        foreach (ITreeNodeDefinition nodeDefinition in treeNodeDefinition.Nodes)
        {
            this.SearchNodesByRelationshipId(nodeDefinition, relationshipId, tndList);
        }
    }
}

3) 另一个问题。意义重大。您进行迭代的方式是“深度优先”递归。这种方法并不可靠，可能会导致 'StackOverflowException' 。因为递归方法调用的长链。

我建议您阅读有关树上下文中的迭代和递归算法，并实现迭代方法。

仅供参考：还有另一种使用“recursion”方法避免“stackOverfrwException”的方法 - tail recursion，但是 afaik，@987654328 中没有这种机制@，但这种机制存在于F#和其他函数式语言中。

迭代方法的工作原理，用伪代码简要说明：

put the root to the collection X (which is queue for '*breadth-first*' and stack for '*depth-first*')
Do while X is not empty
    var currentNode = get next node from X
    process current root (do checks that you need, aggregate data etc.)
    get child nodes of the currentNode, save them into X

• https://www.quora.com/Is-recursion-faster-than-loops

• Way to go from recursion to iteration