我正在编写以下功能。给定两组索引（*_indices_lhs* 和 *_indices_rhs*）的根节点，对于出现在左侧和右侧的索引中的每个索引，它都会创建一个子节点，其中
例如 ik, kn 将有一个子节点，该子节点的 *_indices_lhs* 和 *_indices_rhs* 分别为 i 和 n。例如 ikn，ikn（左右两侧的索引相同），预期的结果是您将有3个子节点 kn，kn；in，in；ik，ik，当然，这3个子节点将分别有2个更多的子节点。为了实现这一点，我使用 while 循环迭代树。我将创建根节点，然后保持已创建子节点的引用队列，然后只要此队列不为空，我将迭代以创建可能会生成节点的更多子节点/节点。当我遍历队列的所有内容并且它为空时，我就知道不会再生成更多的子节点。我为此目的实现的代码在这里：
节点如下所示，子节点在成员函数 generate_further_paths 中创建。我创建了所有可能的子节点组合并将它们添加到 _children 成员变量中。
```python
class Node:
    _parent = None
    _depth = 0
    _indices_lhs = list()
    _indices_rhs = list()
    _children_contractions = list()
    _children = list()
    def __init__(self, indices_lhs: list[str], indices_rhs: list[str], depth: int = 0):
        self._indices_lhs = indices_lhs
        self._indices_rhs = indices_rhs
        self._depth = depth
        print(self)
    def generate_further_paths(self):
        if len(self._indices_lhs) == 0 or len(self._indices_rhs) == 0:
            return
        if len(self._indices_lhs) == 1 and len(self._indices_rhs) == 1 \
            and self._indices_lhs[0] == self._indices_rhs[0]:
            return
        print("D1: ", self._depth, ": ", self._indices_lhs, " | ", self._indices_rhs)
        intersected_indices = []
        for i in self._indices_lhs:
            if i in self._indices_rhs:
                intersected_indices.append(i)
        if len(intersected_indices) == 0:
            return
        print("Intersected indices: ", intersected_indices)
        for ii in intersected_indices:
            child_lhs = copy.deepcopy(self._indices_lhs)
            child_lhs.remove(ii)
            child_rhs = copy.deepcopy(self._indices_rhs)
            child_rhs.remove(ii)
            child = Node(child_lhs, child_rhs, self._depth + 1)
            self._children_contractions.append(ii)
            self._children.append(copy.deepcopy(child))
    def __str__(self):
        return f"Node constructed depth {self._depth}:" + "".join(self._indices_lhs) + " * " + \
            "".join(self._indices_rhs) + ", " + str(len(self._children)) + " children"
    def __repr__(self):
        return '<tree node representation>'

free_lhs = ["i", "k", "n"]
free_rhs = ["i", "k", "n"]
beginNode = Node(free_lhs, free_rhs, 0)
beginNode.generate_further_paths()
queue = copy.copy(beginNode._children)
while len(queue) != 0:
    nq = list()
    for child in queue:
        child.generate_further_paths()
        nnq = copy.copy(child._children)
        nq += nnq
    queue = nq

D1:  1 :  ['i', 'k']  |  ['i', 'k']
Intersected indices:  ['i', 'k']
Node constructed depth 2:k * k, 4333 children
Node constructed depth 2:i * i, 4334 children

<details>
<summary>英文:</summary>
I am writing the following functionality. A root nodes is given with 2 set of indices (*_indices_lhs* and *_indices_rhs*), and fore every index that apperas in both the left hand side and right hand side it creates a children, where 
For example ik, kn will have one children where the *_indices_lhs* and *_indices_rhs* of the children will be respectively i and n. In the case of for example ikn, ikn (Identical indices on the left and right hand side) the expected outcome is that you would have 3 children kn, kn; in, in; ik, ik and ofc these 3 children would have each 2 more children. To implement this I iterate the tree with a while loop. I would create the root node and then keep a queue of references of created children, and I would then iterate as long as this queue is not empty to create further children/nodes that might create nodes. And when I iterate through all of the queue and when it is empty, then I can know that no more children can be generated. The code I have implemented for this purpose is here:
The node looks as following, children are created in the member function generate_further_paths. I create all the possible children combinations and add them to _children member variable.
```python
class Node:
_parent = None
_depth = 0
_indices_lhs = list()
_indices_rhs = list()
_children_contractions = list()
_children              = list()
def __init__(self, indices_lhs: list[str], indices_rhs: list[str], depth: int = 0):
self._indices_lhs = indices_lhs
self._indices_rhs = indices_rhs
self._depth = depth
print(self)
def generate_further_paths(self):
if len(self._indices_lhs) == 0 or len(self._indices_rhs) == 0:
return
if len(self._indices_lhs) == 1 and len(self._indices_rhs) == 1 \
and self._indices_lhs[0] == self._indices_rhs[0]:
return
print(&quot;D1: &quot;, self._depth, &quot;: &quot;, self._indices_lhs, &quot; | &quot;, self._indices_rhs)
intersected_indices = []
for i in self._indices_lhs:
if i in self._indices_rhs:
intersected_indices.append(i)
if len(intersected_indices) == 0:
return
print(&quot;Intersected indices: &quot;, intersected_indices)
for ii in intersected_indices:
child_lhs = copy.deepcopy(self._indices_lhs)
child_lhs.remove(ii)
child_rhs = copy.deepcopy(self._indices_rhs)
child_rhs.remove(ii)
child = Node(child_lhs, child_rhs, self._depth + 1)
self._children_contractions.append(ii)
self._children.append(copy.deepcopy(child))
def __str__(self):
return f&quot;Node constructed depth {self._depth}:&quot; + &quot;&quot;.join(self._indices_lhs) + &quot; * &quot; + \
&quot;&quot;.join(self._indices_rhs) + &quot;, &quot; + str(len(self._children)) + &quot; children&quot;
def __repr__(self):
return &#39;&lt;tree node representation&gt;&#39;

free_lhs = ["i", "k", "n"]
free_rhs = ["i", "k", "n"]
beginNode = Node(free_lhs, free_rhs, 0)
beginNode.generate_further_paths()
queue = copy.copy(beginNode._children)
while len(queue) != 0:
    nq = list()
    for child in queue:
        child.generate_further_paths()
        nnq = copy.copy(child._children)
        nq += nnq
    queue = nq

D1:  1 :  ['i', 'k']  |  ['i', 'k']
Intersected indices:  ['i', 'k']
Node constructed depth 2:k * k, 4333 children
Node constructed depth 2:i * i, 4334 children