二叉树也可以用数组来存储， 给定一个数组，树的根节点的值储存在下标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))