Question

我正在寻找一种更好或更优化的方法来复制（或在实际问题中，转换）一个n-ary树，而不使用使用递归。关于我试图解决的一般情况的一些细节如下

树是n-ary（即，每个级别最多n个节点）
儿童有父母的链接，父母有所有儿童的名单
在树的任何给定级别中，任何节点都可以是叶子或分支

我提出了以下解决方案。一般方法是使用两个（三个）堆栈。第一个跟踪原始树中需要处理的项目，第二个跟踪新创建的副本，以便我们可以适当地分配节点之间的链接（这可以分为两个堆栈而不是元组，因此三个）。这有效，但它有许多不受欢迎的方面，首先是它感觉非常尴尬。我认为必须有一个更好的方法来做到这一点，我遗漏了一些东西（或多个明显的东西）。

有没有人遇到过更直接/更有效的方法？

public TreeNode ConvertTree(TreeNode root)
{
    Stack<TreeNode> processingStack = new Stack<TreeNode>();
    Stack<Tuple<Int32, TreeNode>> resultStack = new Stack<Tuple<Int32, TreeNode>>();
    TreeNode result = null;

    processingStack.Push(root);
    while (processingStack.Count > 0)
    {
        var currentProcessingNode = processingStack.Pop();
        var parentNode = resultStack.Count > 0 ? resultStack.Pop() : null;

        // Copies all leaf nodes and assigns parent, if applicable.
        var newResultNode = CopyNodeData(currentProcessingNode, parentNode != null ? parentNode.Item2 : null);

        // Push sub-branch nodes onto the processing stack, and keep track of how many for
        // each level.
        var subContainerCount = 0;
        foreach (var subContainer in currentProcessingNode.Children.Where(c => !c.IsLeaf))
        {
            processingStack.Push(subContainer);
            subContainerCount++;
        }

        // If we have have not processed all children in this parent, push it back on and
        // decrement the counter to keep track of it.
        if (parentNode != null && parentNode.Item1 > 1)
        {
            resultStack.Push(new Tuple<Int32, TreeNode>(parentNode.Item1 - 1, parentNode.Item2));
        }

        // If this node has sub-branches, push the newly copied node onto the result/tracking
        // stack
        if(subContainerCount > 0)
            resultStack.Push(new Tuple<Int32, TreeNode>(subContainerCount, newResultNode));

        // The very first time a new node is created, track it to return as the result
        if (newResultNode.IsRoot)
            result = newResultNode;
    }

    return result;
}

请注意，我 NOT 正在寻找递归解决方案。是的我意识到它们在许多情况下都是可用的，简单的和适当的。这个问题更多的是关于如何以迭代的方式有效地完成这种类型的操作，而不仅仅是如何将它拉下来。

Answer 1

我会抓紧抓住它。这假设链接指向父节点，您可以检索节点上的子节点数并按索引访问子节点。

static TreeNode Clone(TreeNode root)
{
    var currentOriginal = root;
    var currentCloned = Copy(root, null);
    var clonedRoot = currentCloned;
    while (currentOriginal != null)
    {
        if (currentCloned.Children.Count == currentOriginal.Children.Count)
        {
            currentOriginal = currentOriginal.Parent;
            currentCloned = currentCloned.Parent;
        }
        else
        {
            var targetChild = currentOriginal.Children[currentCloned.Children.Count];
            currentOriginal = targetChild;
            currentCloned = Copy(currentOriginal, currentCloned);
        }
    }
    return clonedRoot;
}


static TreeNode Copy(TreeNode source, TreeNode parent) { ... }

我们初始化：

原始树的工作变量
克隆树的工作变量
克隆树的根（因此代码更清晰，替代方法是返回currentCloned并将第一个if分支中的行更改为currentCloned = currentCloned.Parent ?? currentCloned）

我们循环直到没有更多的东西可以处理。有两种选择：

克隆的子项数与源的子项数相同。这意味着有一个叶节点或所有子节点都已处理。向上移动到父母。
克隆的子项少于原始子项，这意味着应该处理一个或多个子项，使用上面的索引技巧处理下一个子项。

因为我们可以使用树本身链接到父级，所以不需要堆栈来帮助导航。

有没有更好的方法迭代地克隆N-ary树？

1 个答案: