Question

为更多示例编辑了更大的树。

我有一个树结构，我需要生成所有可能的排列，但有一些限制。鉴于这样的树：

    A1----(B1, B2)
     \    
      \___(C1)
             \__(E1, E2)
/       
-  A2----(B3, B4)
\     \     \
       \     \__(D1)
        \
         \_(F1, F2)
                |
                (D4)   

    A3----(B5, B6)
                \__(D2, D3)

或者，如果这有点模糊，那么使用Perl表示法完成相同的结构：

my $nodes = [
{
    name => 'A1',
    children => [
        [ { name => 'B1', children => []  }, 
          { name => 'B2', children => []  }
        ],
        [
          { name => 'C1', 
                    children => [
                        [
                            { name => 'E1', children => [] },
                            { name => 'E2', children => [] }
                        ]
                    ]
            }
        ]
    ]
},
{
    name => 'A2',
    children => [
        [ { name => 'B3', 
                children => [
                    [
                        { name => 'D1', children => [] }
                    ]
                ] 
          },
          { name => 'B4', children => [] }
        ],
        [
          { name => 'F1', children => [] },
          { name => 'F2', children => [
                        [ { name => 'D4', children => [] } ]
                    ]
            }
        ]
    ]
},
{
    name => 'A3',
    children => [
        [ { name => 'B5', children => [] },
          { name => 'B6', children => [
                    [ { name => 'D2', children => [] },
                      { name => 'D3', children => [] }
                    ] 
                ]                 
            }
        ]
    ]
}

];

（坦率地说，如果你能在可读 Perl中解决这个问题，我也会接受它。）

我正在寻找遍历树并从顶层向下检索所有可能的“路径”。节点的所有后代组必须在“路径”中由正好1个成员表示。例如，在A1中，需要表示（B1，B2）中的一个和（C1）中的一个。因此，从A1开始的每条路径都将以下列之一开始：

A1 B1 C1

或

A1 B2 C1

如果B1，B2或C1有孩子，那么也需要表示。

为上述树手工完成，我得到了这些可能性：

A1 B1 C1 E1
A1 B1 C1 E2
A1 B2 C1 E1
A1 B2 C1 E2

A2 B3 D1 F1
A2 B3 D1 F2 D4
A2 B4 F1
A2 B4 F2 D4

A3 B5
A3 B6 D2
A3 B6 D3

此处的每个节点都是DataRow对象：

internal class DataRow
{
    internal string tag = "";
    internal int id = 0;
    internal Dictionary<string, List<DataRow>> children = null;

    internal DataRow(int id, string tagname)
    {
        this.tag = tagname;
        this.id = id;
    }        internal void AddChildren(string type, List<DataRow> drList)
    {
        if (children == null)
            children = new Dictionary<string, List<DataRow>>();
        if (!children.ContainsKey(type))
            children[type] = new List<DataRow>();
        children[type].AddRange(drList);
    }
    internal void AddChild(string type, DataRow dr)
    {
        List<DataRow> drList = new List<DataRow>();
        drList.Add(dr);
        AddChildren(type, drList);
    }
    public override string ToString()
    {
        return this.tag + " " + this.id;
    }
}

要构建上面的示例树（E和F级别除外，稍后添加）：

        DataRow fullList = new DataRow(null, "");
        DataRow dr, dr2, dr3;

        // First node above
        dr = new DataRow(1, "A");
        List<DataRow> drList = new List<DataRow>();
        drList.Add(new DataRow(1, "B"));
        drList.Add(new DataRow(2, "B"));
        dr.AddChildren("B", drList);
        drList.Clear();
        dr2 = new DataRow(1, "C");
        dr2.AddChild("C", new DataRow(1, "E"));
        dr2.AddChild("C", new DataRow(2, "E"));
        drList.Add(dr2);
        dr.AddChildren("C", drList);
        fullList.AddChild("A", dr);


        // Second Node above (without the "F" stuff)
        drList.Clear();
        dr = new DataRow(3, "B");
        dr.AddChild("D", new DataRow(1, "D"));
        drList.Add(dr);
        drList.Add(new DataRow(4, "B"));
        dr = new DataRow(2, "A");
        dr.AddChildren("B", drList);
        fullList.AddChild("A", dr);

        // Third node above
        drList.Clear();
        dr3 = new DataRow(6, "B");
        dr3.AddChild("B", new DataRow(2, "D"));
        dr3.AddChild("B", new DataRow(3, "D"));
        dr2 = new DataRow(3, "A");
        dr2.AddChild("B", new DataRow(5, "B"));
        dr2.AddChild("B", dr3);
        fullList.AddChild("A", dr2);

走遍整棵树是微不足道的：

    internal void PermutedList()
    {
        if ( children == null ) return;
        foreach (string kidType in children.Keys)
        {
            foreach (DataRow dr in children[kidType])
            {
                dr.PermutedList();
            }
        }
    }

但这不是我需要的。此问题是完整的树步行，但按特定顺序。我得不到什么？这是什么样的散步？

我有一个凌乱的＆amp;我在10年前用Perl写的这个实现很慢，但是我不能再破译我自己的代码了（对我这么羞耻！）。

修改：下面的图表和列表已经扩展，代码没有。

如果我可以描述图表，我可以编程。如果我知道它叫什么，我可以查一查。但我不能。那么让我再解释一下。

存储桶名称不重要！

每个节点都有“孩子们的桶”。 A1有两个桶，一个包含“B”，另一个包含“C”。如果这就是全部（并且C下没有铲斗）我会有“A1 B1 C1”和“A1 B2 C1” - 至少有一个来自所有儿童桶的代表。

所以我认为每个桶都需要孩子的交叉产品（一直向下）。

Answer 1

使用以下子目录：

use 5.10.0;  # for // (aka defined-or)

use subs 'enumerate';
sub enumerate {
  my($root) = @_;

  my $kids = $root->{children};
  return [ $root->{name} // () ]
    unless @$kids;

  my @results;
  foreach my $node (@{ $kids->[0] }) {
    my @fronts = map [ $root->{name} // (), @$_ ],
                     enumerate $node;

    my @below = enumerate {
      name => undef,
      children => [ @{$kids}[1 .. $#$kids ] ],
    };

    foreach my $a (@fronts) {
      foreach my $b (@below) {
        push @results => [ @$a, @$b ];
      }
    }
  }

  @results;
}

您可以使用

进行打印

foreach my $tree (@$nodes) {
  foreach my $path (enumerate $tree) {
    print "@$path\n";
  }

  print "\n";
}

获取以下输出：

A1 B1 C1 E1
A1 B1 C1 E2
A1 B2 C1 E1
A1 B2 C1 E2

A2 B3 D1 F1
A2 B3 D1 F2 D4
A2 B4 F1
A2 B4 F2 D4

A3 B5
A3 B6 D2
A3 B6 D3

我上面使用了$path，但它会严重混淆任何维护代码的人，因为路径具有众所周知的含义。你可以通过一点点聪明来完成命名问题：

print join "\n" =>
      map { join "" => map "@$_\n", @$_ }
      map [ enumerate($_) ] => @$nodes;

Answer 2

每个节点都应该知道它的父节点（GetParentRow），因此您可以将父节点作为参数传递给递归方法。这样，当你到达'leaf'时，你可以递归地追溯到root。

我不确定它是否是最有效的方式，但我认为它应该能为您提供所需的结果。

Answer 3

可以按照以下任何顺序执行树步行。对于根节点，将所有子节点放入DATA_STRUCTURE（如下所述）。然后从DATA_STRUCTURE中取出一个节点，并将其所有子节点放入DATA_STRUCTURE中。继续，直到DATA_STRUCTURE为空。

诀窍是选择正确的DATA_STRUCTURE。对于有序（深度优先）遍历，可以使用堆栈。（必须以相反的顺序将子项推入堆栈。）要进行深度优先遍历，可以使用队列。

对于更复杂的排序，优先级队列是票证。只需根据您使用的标准，根据您希望遍历树的顺序设置优先级。事实上，正确设置优先级也将表现为堆栈或队列，分别导致上述深度优先和广度优先序列。

编辑添加：

树行走算法适用于此类型的数据结构，因为它没有周期。只需在数据结构中为集合中的每个项目添加一个新节点。我想唯一的补充是表示路径的方式。

路径非常简单。你只需要这样的东西：

class Path<T>
{
    T lastNode;
    Path<T> previousNodes;
    public Path(T lastNode, Path<T> previousNodes)
    {
        this.lastNode = lastNode; this.previousNodes = previousNodes;
    }
    public IEnumerable<T> AllNodes()
    {
        return AllNodesBackwards().Reverse();
    }
    private IEnumerable<T> AllNodesBackwards()
    {
        Path<T> currentPath = this;
        while (currentPath != null)
        {
            yield return currentPath.lastNode;
            currentPath = currentPath.previousNodes;
        }
    }
    public T Node { get { return lastNode; } }
}

那么我们所要做的就是走这条路。类似的东西应该做的伎俩：

[删除了错误的解决方案]

再次编辑：

好的，我终于找到了你想要的东西。你想在每个路径中横向穿过不同“kidTypes”的孩子，然后再沿树走下去。

这是一个很大的混乱，但我解决了它：

public void WalkPath2()
{
    Queue<Path<DataRow>> queue = new Queue<Path<DataRow>>();
    queue.Enqueue(new Path<DataRow>(this, null));

    while (queue.Count > 0)
    {
        Path<DataRow> currentPath = queue.Dequeue();
        DataRow currentNode = currentPath.Node;

        if (currentNode.children != null)
        {
            foreach (Path<DataRow> nextPath in currentNode.GetChildPermutations(currentPath))
                queue.Enqueue(nextPath);
        }
        else
        {
            foreach (DataRow node in currentPath.AllNodes())
            {
                Console.Write(node.ToString());
                Console.Write("      ");
            }
            Console.WriteLine();
        }

    }

}

private IEnumerable<Path<DataRow>> GetChildPermutations(Path<DataRow> currentPath)
{
    string firstLevelKidType = null;
    foreach (string kidType in children.Keys)
    {
        firstLevelKidType = kidType;
        break;
    }
    foreach (Path<DataRow> pathPermutation in GetNextLevelPermutations(currentPath, firstLevelKidType))
        yield return pathPermutation;
}

private IEnumerable<Path<DataRow>> GetNextLevelPermutations(Path<DataRow> currentPath, string thisLevelKidType)
{
    string nextLevelKidType = null;
    bool nextKidTypeIsTheOne = false;
    foreach (string kidType in children.Keys)
    {
        if (kidType == thisLevelKidType)
            nextKidTypeIsTheOne = true;
        else
        {
            if (nextKidTypeIsTheOne)
            {
                nextLevelKidType = kidType;
                break;
            }
        }
    }

    foreach (DataRow node in children[thisLevelKidType])
    {
        Path<DataRow> nextLevelPath = new Path<DataRow>(node, currentPath);
        if (nextLevelKidType != null)
        {
            foreach (Path<DataRow> pathPermutation in GetNextLevelPermutations(nextLevelPath, nextLevelKidType))
                yield return pathPermutation;
        }
        else
        {
            yield return new Path<DataRow>(node, currentPath);
        }
    }


}

Answer 4

首先，我以为你想要所有的树木。 http://en.wikipedia.org/wiki/Spanning_tree

但后来我意识到你想要的是一棵树根部的'跨越式步行'。

然后我意识到它（相对）简单。

Foreach leaf

Walk from the leaf to the root

end for

当然，你需要一个真正的数据结构，我不认为Perl的散列哈希会起作用;你需要在每个节点中有一个“父”指针。

检索树结构的所有排列的有效方法

4 个答案: