如何将任意深度的列表迭代转换为指定结构的字典？

需要将固定结构的字典列表转换为嵌套字典：输入列表中的每个元素是包含key和children键的字典，children是同结构的字典列表；转换后每个节点的key作为嵌套字典的键，叶子节点（children为空）对应的值为空字符串。

输入示例 #

[
    {'key': 'a', 'children': [{'key': 'a1', 'children': [{'key': 'a11', 'children': []}]}]},
    {'key': 'b', 'children': [{'key': 'b1', 'children': [{'key': 'b11', 'children': []}]}]}
]

预期输出 #

{'a': {'a1': {'a11': ''}}, 'b': {'b1': {'b11': ''}}}

当前尝试的代码 #

迭代实现（未完成） #

仅能提取所有key值，无法组合成目标嵌套结构：

def get_res(stack, key='key'):
    result = []
    while stack:
        elem = stack.pop()
        if isinstance(elem, dict):
            for k, v in elem.items():
                if k == key:
                    result.append(v)
                stack.append(v)
        elif isinstance(elem, list):
            stack.extend(elem)
    print(result)
    return result

递归实现（未完成） #

无法正确返回嵌套结构：

def gen_x(stack):
    for bx in stack:
        if 'children' not in bx:
            return {bx['key']: ''}
        tem_ls = bx['children']
        xs = gen_x(tem_ls)
        print(xs)

可行的实现方案 #

递归实现 #

思路：对每个节点，生成以其key为键的字典，值由递归处理children得到；若children为空，则值设为空字符串。

def convert_recursive(nodes):
    result = {}
    for node in nodes:
        key = node['key']
        children = node['children']
        if not children:
            result[key] = ''
        else:
            result[key] = convert_recursive(children)
    return result

迭代实现 #

思路：用栈存储待处理的节点和对应的父字典，遍历每个节点时，在父字典中创建当前节点的键，若存在子节点，则将子节点和新创建的子字典推入栈中继续处理。

def convert_iterative(nodes):
    root = {}
    stack = [(nodes, root)]
    while stack:
        current_nodes, parent_dict = stack.pop()
        for node in reversed(current_nodes):
            key = node['key']
            children = node['children']
            if not children:
                parent_dict[key] = ''
            else:
                child_dict = {}
                parent_dict[key] = child_dict
                stack.append((children, child_dict))
    return root

内容的提问来源于stack exchange，提问作者ComplicatedPhenomenon