Question

我有一个Spaghetti Stack（一个N-ary树数据结构，其中子节点有指向父节点的指针） - 从数据库接收。

＆＃34;堆栈＆＃34;从数据库收到的只是一个包含所有节点的列表，所以可以里面有多个堆栈。

节点是数据库中的记录，其中parent.id是另一个相同类型记录的ForeignKey。

class Node_Category:
  def __init__(self, value):
    self.value = value
    parent_id = id

结构是这样的：

Category 1
 -Category 1_1
  --Category 1_1_1
 -Category 1_2
Category_2
Category_3
 -Category 3_1
 -Category 3_2

我需要什么：

现在我知道了孩子的父母。从父节点开始，我需要了解他的孩子。

所以我需要遍历＆＃39; Spaghetti Stack＆＃39;将父节点中的连接添加到子节点，以便我可以从父节点遍历到子节点。

父母可以有0个，一个或多个孩子。

因为我不知道堆栈的深度，所以我试图递归。

此外，我认为一种记忆形式是必要的，因为通过数组循环父节点的父节点会获得多次访问。

我尝试了什么：

   def _recurse_for_parents(self, category, path=None):

    if path is None:
        path = []
    path.append(category)
    if category.parent:
        return self._recurse_for_parents(category.parent, path)
    return path

 for record in categories:
            self._recurse_for_parents(category)

问题：

在循环中，我可以点击父级，第一级孩子，第二级等：

Child1_L2-Child1_L1->parent; Child1_L1->parent; parent->Null
Child1_L1->parent; parent->Null
Child2_L1->parent; parent->Null

所以，我在不同的深度上多次击中相同的路径。此外，对于每条路径，我需要将其父级链接添加回子级。

Answer 1

这在概念上看起来很简单。我没有看到递归实现特别有用的地方。迭代解决方案很简单。我将概述基本概念。

我假设您有一个N个节点的数组，并且每个节点都有一个ID。

我要做的第一件事就是创建一个按ID键入的字典，这些值是具有以下结构的新节点类型：

NewNode
    Id - the node's id
    Children - a list of some type that contains the ids of the node's children
    Whatever other data the database gives you.

对于列表中的每个节点，在字典中查找父节点，并将节点添加到父节点的子节点列表中。

当您在上面的步骤中浏览列表时，您应该遇到一个没有父ID的节点。那是根源。如果没有这样的节点或者有多个节点，则表示您的数据无效。

无论如何，你在字典中查找该节点的id并将其保存为root。

实施例

假设你有两棵树：

           100                  200
         /     \             /   |   \
      101      120         201  210  220
       |      /   \         |         |
      102   121   122      202       221
     /   \               /  |  \
   103   110           203 204 205
    |
   104

所以你有这些节点：

ID      Parent
104     103
103     102
102     101
101     100
100     NULL
110     102
121     120
120     100
122     120
203     202
202     201
201     200
204     202
205     202
210     200
221     220
220     200
200     NULL

我建议您从该列表创建一个字典，由节点ID键入。每个节点都有一个children列表。

现在，从列表中的第一项开始，查找父项，并将该节点添加到父项的子项列表中。因此，对于第一项，您会看到节点104具有父103.您将节点104的引用添加到103的子列表。

然后转到列表中的下一个节点。当你完成后，你的字典看起来像这样：

ID      Parent  Children
104     103     []
103     102     [104]
102     101     [103]
101     100     [102]
100     NULL    [101,110,120]
110     102     []
121     120     []
120     100     [121,122]
122     120     []
203     202     []
202     201     [203,204,205]
201     200     [202]
200     NULL    [201,210,220]
204     202     []
205     202     []
210     200     []
221     220     []
220     200     [221]

您的词典现在包含倒置树。您可以扫描字典，查找Parent值为NULL的节点。那些是你树木的根。每个根都有一个对其子节点的引用数组，这些子节点都有对其子节点的引用等。

Answer 2

一个简单的解决方案可能是下面的一个，假设您的节点由整数表示，并且您的数组是array[2] = 3表示'节点2的父节点是节点3'。让我们调用{{1所有节点的列表（或任何可迭代的），然后：

array

然后要获取给定节点的子节点，您只需按以下步骤处理：

adjacencies = []
for node in tree : # iterate on all your nodes
    adjacencies += [(node.parent_id, node)]

如果您想要更精确的解决方案，您需要向我提供有关您的实施的更多信息;然后我会编辑。

遍历意大利面条堆栈并反转到树

2 个答案:

实施例