描述：

给定一个二叉树，返回所有从根节点到叶子节点的路径。

说明: 叶子节点是指没有子节点的节点。

示例:

输入:

1

/ \\

2 3

\\

5

输出: ["1->2->5", "1->3"]

解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3

解题思路：

递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果。

写树相关的算法，简单说就是，先搞清楚当前 root 节点该做什么，然后根据函数定义递归调用子节点，递归调用会让孩子节点做相同的事情。

二叉树题目的一个难点在于如何通过题目的要求思考出每一个节点需要做什么

按照深度遍历依次经历每一个节点，然后两个节点之间用"→"相连。

自己的解法实现

def binaryTreePaths(self, root):

if not root: return []

stack, res = [[root, ""]], []

while stack:

node, tmp = stack.pop(0)

if not node: continue

# 如果当前节点是叶子节点，将其拼装后放入最终结果集中

if node and not (node.left or node.right):

res.append(tmp + str(node.val))

continue

# 如果当前节点不是叶子节点，将其左子树和新路径放入队列中

if node.left:

stack.append([node.left, tmp + str(node.val) + "->"])

# 如果当前节点不是叶子节点，将其右子树和新路径放入队列中

if node.right:

stack.append([node.right, tmp + str(node.val) + "->"])

return res

网上比较优秀的解法

解法一

方法一：深度优先搜索 思路与算法

最直观的方法是使用深度优先搜索。在深度优先搜索遍历二叉树时，我们需要考虑当前的节点以及它的孩子节点。

如果当前节点不是叶子节点，则在当前的路径末尾添加该节点，并继续递归遍历该节点的每一个孩子节点。 如果当前节点是叶子节点，则在当前路径末尾添加该节点后我们就得到了一条从根节点到叶子节点的路径，将该路径加入到答案即可。 如此，当遍历完整棵二叉树以后我们就得到了所有从根节点到叶子节点的路径。当然，深度优先搜索也可以使用非递归的方式实现，这里不再赘述。

def binaryTreePaths2(self, root):

paths = []

def construct_paths(node, path):

if node:

path += str(node.val)

if not node.left and not node.right: # 当前节点是叶子节点

paths.append(path) # 把路径加入到答案中

else:

path += "->" # 当前节点不是叶子节点，继续递归遍历

construct_paths(node.left, path)

construct_paths(node.right, path)

construct_paths(root, '')

return paths

解法二

方法二：广度优先搜索 思路与算法

我们也可以用广度优先搜索来实现。我们维护一个队列，存储节点以及根到该节点的路径。一开始这个队列里只有根节点。在每一步迭代中，我们取出队列中的首节点，如果它是叶子节点，则将它对应的路径加入到答案中。如果它不是叶子节点，则将它的所有孩子节点加入到队列的末尾。当队列为空时广度优先搜索结束，我们即能得到答案。

def binaryTreePaths3(self, root):

from collections import deque

paths = list()

if not root: return paths

node_queue = deque([root])

path_queue = deque([str(root.val)])

while node_queue:

node = node_queue.popleft()

path = path_queue.popleft()

if not node.left and not node.right:

paths.append(path)

else:

if node.left:

node_queue.append(node.left)

path_queue.append(path + '->' + str(node.left.val))

if node.right:

node_queue.append(node.right)

path_queue.append(path + '->' + str(node.right.val))

return paths

解法三

首先初始化临时路径为空“” 之后每下降一层，就将临时路径跟当前节点的值拼接上 对于任何一个节点，要不就是叶子节点，要不就是非叶子节点，我们可以这样处理：

如果当前节点如果是叶子节点，那么拼接的内容是root.val 如果当前节点不是叶子节点，那么拼接的内容是root.val+"->"

def binaryTreePaths4(self, root):

if not root: return []

res = []

def dfs(node, tmp):

if not node: return

# 如果是叶子节点，将 root.val 拼接到临时路径中

if node and not (node.left or node.right):

res.append(tmp + str(root.val))

return

# 如果当前节点不是叶子节点，将 root.val+"->" 拼接到临时路径中

if node.left:

dfs(node.left, tmp + str(node.val) + "->")

if node.right:

dfs(node.right, tmp + str(node.val) + "->")

dfs(root, "")

return res

相关知识总结和思考

相关知识：

BFS：广度/宽度优先。其实就是从上到下，先把每一层遍历完之后再遍历一下一层。

可以使用Queue的数据结构。我们将root节点初始化进队列，通过消耗尾部，插入头部的方式来完成BFS。

二叉搜索树(BST)的特性：

若它的左子树不为空，则所有左子树上的值均小于其根节点的值

若它的右子树不为空，则所有右子树上的值均大于其根节点的值

它的左右子树也分别为二叉搜索树

递归与迭代的区别

递归：重复调用函数自身实现循环称为递归； 迭代：利用变量的原值推出新值称为迭代，或者说迭代是函数内某段代码实现循环；