给定一个二叉树，返回它的 前序 遍历。
示例:
输入: [1,null,2,3]
1
2
/
3
输出: [1,2,3]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？
要求输出的节点放在一个列表中。所以使用递归算法的话，要先在solution类里添加一个空列表，这样这个列表在整个类中都可以使用。
前序遍历
递归算法：
思路：
如果输入的root为空，就直接返回，如果非空的话，就先将输入节点放入列表中，然后对root的左子树使用前序遍历函数，然后对右子树使用前序遍历函数。注意递归使用前序遍历函数的时候，语句为self.preorderTraversla()
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def __init__(self):
self.re = []
def preorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
if root is None:
return
self.re.append(root.val)
self.preorderTraversal(root.left)
self.preorderTraversal(root.right)
return self.re
迭代算法：
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def preorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
stack = [] # 栈，用来压入弹出TreeNode
List = [] # 列表，用来存放节点的值，同时实现前序遍历的顺序输出
while root or stack:
if root:
stack.append(root)
List.append(root.val)
root = root.left
else:
root = stack.pop()
root = root.right
return List
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def preorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
stack = [] # 栈，用来压入弹出TreeNode
List = [] # 列表，用来存放节点的值，同时实现前序遍历的顺序输出
while root or stack: # 如果节点不为空（继续查找）或者栈不为空（还有节点的右子树未查找）
while root:
# 以root为根节点的树入栈，并将root.val放进列表
# 然后读取该节点的左子树，将root更新为左子树
# 如果root不空，就继续这个循环
# 如果root为空，就退出循环，弹出这个root，读取其右子树。
stack.append(root)
List.append(root.val)
root = root.left
# 不断的往外弹TreeNode，如果该node的右子树为空，就不会进入while root的loop，继续往外pop treenode，如果不为空的话就进入while root的loop，处理这个节点的左子树
root = stack.pop()
root = root.right
return List
中序遍历
递归：
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def __init__(self):
self.re = []
def preorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
if root is None:
return
self.inorderTraversal(root.left)
self.re.append(root.val)
self.inorderTraversal(root.right)
return self.re
迭代
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def inorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
stack = [] #栈，用来不断地压入和弹出树
List = [] #列表，用来存储遍历到的节点的值
while root or stack:
#一定注意while loop的条件。如果root为空，说明输入root就是空，此时stack也是空，直接返回空列表。这个时候就包括了输入为空的特殊情况。
while root:
#当root不是空的时候，以root为根节点的树入栈，然后更新root的左子树为root。
#（中序遍历：左根右，要先不断寻找左子树，然后再进行出栈以及将节点的值放进列表的操作。）
#退出循环时root为空，也就是说上一步入栈的节点没有左孩子，此时pop出该节点，并将它的值放进列表，然后看它的右子树。
#如果右子树为空，就继续从栈中pop，此时pop出的节点是刚刚放进列表中的节点的父节点，将该节点也放进列表，然后看其右孩子。如果右子树不为空，此时进入while loop，继续查看其左子树部分。
stack.append(root)
root=root.left
root = stack.pop()
List.append(root.val)
root = root.right
return List
后序遍历
递归
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def __init__(self):
self.re = []
def postorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
# 左右根
if root is None:
return
self.postorderTraversal(root.left)
self.postorderTraversal(root.right)
self.re.append(root.val)
return self.re
迭代：
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def postorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
# 左右根
stack = []
List = []
while root or stack:
# 如果root非空，入栈，并将root的值放在列表首个位置，然后更新root为其右子树，不断循环，这样就可以把每个子树的根节点都放在列表的最后。
# 如果root空，那么就将刚才入栈的子树pop出，然后读取其左子树
if root:
stack.append(root)
List.insert(0,root.val)
root = root.right
else:
root = stack.pop()
root = root.left
return List
第三种方法，也可以利用前序遍历得到的列表——根左右，将前序遍历过程改成根右左，返回列表，该列表的倒序为左右根，即为后序遍历得到的列表。
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def postorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
stack = []
List = []
while root or stack:
if root:
stack.append(root)
List.append(root.val)
root = root.right
else:
root = stack.pop()
root = root.left
return List[::-1]
层次遍历
给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def levelOrder(self, root):
"""
:type root: TreeNode
:rtype: List[List[int]]
"""
if not root:
return
stack = [root]
result = []
while stack:
temp = []
next_layer = []
for node in stack:
temp.append(node.val)
if node.left:
next_layer.append(node.left)
if node.right:
next_layer.append(node.right)
result.append(temp)
stack = next_layer
return result
给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def levelOrderBottom(self, root):
"""
:type root: TreeNode
:rtype: List[List[int]]
"""
if not root:
return
result = []
stack = [root]
while stack:
temp = []
len_stack = len(stack)
for i in range(len_stack):
node = stack.pop(0)
temp.append(node.val)
if node.left:
stack.append(node.left)
if node.right:
stack.append(node.right)
# 因为要求从树的底层网上层次遍历，所以在退出for loop之后，得到每层的根节点应该插在列表的最前端，区别于上一题中的result.append()。
result.insert(0,temp)
return result
扫一扫
1038
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
