(Python)最小叶子节点

二叉树也可以用数组来存储， 给定一个数组，树的根节点的值储存在下标1
对于储存在下标n的节点，他的左子节点和右子节点分别储存在下标2*n和2*n+1
并且我们用-1代表一个节点为空，给定一个数组存储的二叉树， 
试求从根节点到最小的叶子节点的路径， 路径由节点的值组成。
输入：
输入一行为数组的内容， 数组的每个元素都是正整数，元素间用空格分割， 注意第一个元素即为根节点的值，
即数组的第n元素对应下标n，下标0在树的表示中没有使用，所以我们省略了， 输入的树最多为 7 层。
输出：
输出从根节点到最小叶子节点的路径上各个节点的值， 由空格分割， 用例保证最小叶子节点只有一个。
示例一：
输入：
3 5 7 -1 -1 2 4
输出：
3 7 2

示例二：
输入：
5 9 8 -1 -1 7 -1 -1 -1 -1 -1 6
输出：
5 8 7 6

class Node:
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


def list_to_tree(nums):  # 递归实现 列表转二叉树
    def level(index):
        if index >= len(nums):
            return None
        root = Node(nums[index])
        root.left = level(2 * index + 1)
        root.right = level(2 * index + 2)
        return root

    return level(0)


def get_min_leaf(root):
    leaf_node = []
    leaf_num = []
    queue = [root]
    while queue:
        # print(queue)
        for _ in range(len(queue)):
            cur_node = queue.pop(0)
            if not cur_node.left and not cur_node.right and cur_node.val != -1:
                leaf_node.append(cur_node)
                leaf_num.append(cur_node.val)
            if cur_node.left:
                queue.append(cur_node.left)
            if cur_node.right:
                queue.append(cur_node.right)
    # print(leaf_node)
    min_leaf_num = min(leaf_num)
    return min_leaf_num


def tree_paths_with_min_leaf_node(root, min_leaf_node):
    paths = []
    if not root:
        return []

    def dfs(node, path):
        if not node.left and not node.right:
            paths.append(list(eval(path)))
        else:
            path += ','
            if node.left:
                dfs(node.left, path + str(node.left.val))
            if node.right:
                dfs(node.right, path + str(node.right.val))

    dfs(root, str(root.val))
    # print(paths)
    for p in paths:
        if min_leaf_node in p:
            return p


nums = list(map(int, input().split()))
min_leaf_num = get_min_leaf(list_to_tree(nums))
print(tree_paths_with_min_leaf_node(list_to_tree(nums), min_leaf_num))