Python 使用生成族谱树的元组列表拆分元组

让我们使用元组和列表来表示族谱。 每个人都表示为一个元组。元组的第一个元素是此人的姓名。元组的第二个元素是包含此人的子级的列表。每个子对象本身都表示为一个元组。如果一个人没有孩子，他/她的孩子列表为空。 例如，如果玛丽没有孩子，她将被表示为（'Mary'，[]）。 如果Jane有两个孩子，分别叫Nick和Wendy，Nick和Wendy都没有孩子，那么Jane表示为（'Jane'，[（'Nick'，[]），（'Wendy'，[]））。 如果玛丽和简是弗兰克的孩子，而弗兰克没有其他孩子，那么弗兰克被表示为（'Frank'，[（'Mary'，[]），（'Jane'，[（'Nick'，[]），（'Wendy'，[]））。 下图显示了它们之间的关系：

定义一个名为

get_family_members（）

的函数，该函数接受一个名为head的人的表示形式，该人表示家族树的头部。头部可能有多个子女、孙辈、曾孙辈等。该函数返回列表中此人家庭的所有成员（包括他/她自己）。成员应按代排序。换句话说，第n代人应该总是出现在第（n-1）代人之后。同样，同一代人应该根据他们在原始列表中的顺序进行排序。例如，如果Nick和Wendy是同一代人，并且Nick在原始列表中出现在Wendy之前，则Nick应在返回的列表中出现在Wendy之前

以下是我所做的：

<代码>def get U族成员（head）： #修改下面的代码 new_dict={} return_list=[] 新列表=标题 #在中附加第一个元素 返回\u列表。追加（新\u列表[0]） 新目录[新目录[0]]=新目录[1] #新建列表=新建列表[1] 键=新列表[0] 打印（新命令[键]） 结束=错误 j=0 如果新命令[键]！=[]: 当end==False时： i=0 对于新目录[key]中的tuple1： 如果tuple1[i]不在返回列表中： return\u list.append（tuple1[i]） 新的dict[tuple1[i]=tuple1[i+1] 打印（“元素”，元组1[i]） 打印（“新列表”，新目录[tuple1[i]]） 打印（“退货清单”，退货清单） 如果tuple1[i+1]！=[]: key=tuple1[i] 其他： 结束=真 返回列表 打印（“键”，键） 返回[键] 但是当我使用这个测试用例时，它似乎是错误的：

print("Test Case #1:")
print()

family_head = ('Mary', [])
result_list = get_family_members(family_head)
print("Expected: ['Mary']")
print("Actual  : " + str(result_list))
print()
print("Expected type of returned value: <class 'list'>")
print("Actual type of returned value  : " + str(type(result_list)))
print()
print("====================")
print()

# Test Case 2:
print("Test Case #2:")
print()

family_head = ('Jane', [('Nick', []), ('Wendy', [])])
result_list = get_family_members(family_head)
print("Expected: ['Jane', 'Nick', 'Wendy']")
print("Actual  : " + str(result_list))
print()
print("====================")
print()

# Test Case 3:
print("Test Case #3:")
print()

family_head = ('Frank', [('Mary', []), ('Jane', [('Nick', [])])])
result_list = get_family_members(family_head)
print("Expected: ['Frank', 'Mary', 'Jane', 'Nick']")
print("Actual  : " + str(result_list))
print()
print("====================")
print()

# Test Case 4:
print("Test Case #4:")
print()

family_head = ('Alan', [('Bob', [('Chris', [])]), ('Eric', [])])
result_list = get_family_members(family_head)
print("Expected: ['Alan', 'Bob', 'Eric', 'Chris']")
print("Actual  : " + str(result_list))
print()
print("====================")
print()

# Test Case 5:
print("Test Case #5:")
print()

family_head = ('Alan', [('Bob', [('Chris', []), ('Debbie', [('Cindy', [])])]), ('Eric', [('Dan', []), ('Fanny', [('George', [])])]), ('Hannah', [])])
result_list = get_family_members(family_head)
print("Expected: ['Alan', 'Bob', 'Eric', 'Hannah', 'Chris', 'Debbie', 'Dan', 'Fanny', 'Cindy', 'George']")
print("Actual  : " + str(result_list))
print()
print("====================")
print()

print（“测试用例1:）
打印（）
家庭户主=（‘玛丽’，[]）
结果列表=获取家庭成员（家庭负责人）
打印（“应为：['Mary']”）
打印（“实际：+str（结果列表））
打印（）
打印（“返回值的预期类型：”）
打印（“返回值的实际类型：+str（类型（结果列表）））
打印（）
打印（“===============================”）
打印（）
#测试用例2：
打印（“测试用例2:）
打印（）
家庭户主=（'Jane'，[（'Nick'，[]），（'Wendy'，[]））
结果列表=获取家庭成员（家庭负责人）
打印（“应为：['Jane'、'Nick'、'Wendy']”）
打印（“实际：+str（结果列表））
打印（）
打印（“===============================”）
打印（）
#测试用例3：
打印（“测试用例3:）
打印（）
家庭户主=（'Frank'，[（'Mary'，[]），（'Jane'，[（'Nick'，[]））
结果列表=获取家庭成员（家庭负责人）
打印（“预期为：['Frank'、'Mary'、'Jane'、'Nick']”）
打印（“实际：+str（结果列表））
打印（）
打印（“===============================”）
打印（）
#测试用例4：
打印（“测试用例4:）
打印（）
家庭户主=（'Alan'，[（'Bob'，[（'Chris'，[]），（'Eric'，[]））
结果列表=获取家庭成员（家庭负责人）
打印（“应为：['Alan'、'Bob'、'Eric'、'Chris']”）
打印（“实际：+str（结果列表））
打印（）
打印（“===============================”）
打印（）
#测试用例5：
打印（“测试用例#5:”）
打印（）
家庭户主=（'Alan'，[（'Bob'，[（'Chris'，[]），（'Debbie'，[（'Cindy'，[]）），（'Eric'，[（'Dan'，[]），（'Fanny'，[（'George'，[]），（'Hannah'，[]））
结果列表=获取家庭成员（家庭负责人）
打印（“预期：['Alan'，'Bob'，'Eric'，'Hannah'，'Chris'，'Debbie'，'Dan'，'Fanny'，'Cindy'，'George']）
打印（“实际：+str（结果列表））
打印（）
打印（“===============================”）
打印（）

考虑以下树

                    Root
    1           2           3           4
11  12  13   21   22                41      42

可以写为

                    (Root,[
    (1,[(11,[]),12,13]),  (2,[21,22]), (3,[]), (4,[41,42])
])

输出应该是

[Root, 1 ,2, 3, 4, 11, 12, 13, 21, 22]

（注意，对于所有的叶子（11除外），我没有编写

（12，[]）

元组，而是直接编写原语类型

12

现在这种遍历是调用

由于我们有一个没有循环的树，bfs可以进一步简化

• 仍然保留将当前“儿童”的探索推迟到堆栈后面的想法
• 关于元组“11”的内容，

  stack+=children

  没有被修改

  if children=[]

  ，所以这仍然可以

def get_family_members(family):
    (root, children) = family
    L = [root]
    stack = children

    while len(stack):
        node = stack.pop(0)
        #if we pushed a leaf
        if type(node) is not tuple:
            L += [node]
        else:
            #add children to the __back__ of the stack
            (child, children) = node
            L += [child]
            stack += children
    return L
fam = (0,[
    (1,[(11,[]),12,13]),  (2,[21,22]), (3,[]), (4,[])
])
print(get_family_members(fam))
#[0, 1, 2, 3, 4, 11, 12, 13, 21, 22]