二叉树基础知识：
《大话数据结构》— “ 二叉树的遍历”
二叉树基础知识总结
剑指offer面试题06----重建二叉树
leetcode–94–二叉树的中序遍历
二叉树的前中后序遍历可以用递归和迭代两种方式实现，层序遍历使用BFS（广度优先搜索）实现。
递归实现:
- 前序遍历:打印-左-右
- 中序遍历:左-打印-右
- 后序遍历:左-右-打印
二叉树前序遍历：
解题思路1: 递归法
代码:
class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution(object):
def __init__(self):
self.ret = []
def preorderTraversal(self, root):
if not root:
return []
if root.val:
self.ret.append(root.val)
if root.left:
self.preorderTraversal(root.left)
if root.right:
self.preorderTraversal(root.right)
return self.ret
解题思路2: 迭代法
从根节点开始，每次迭代弹出当前栈顶元素，并将其子节点压入栈中，先压右子节点再压左子节点。
在这个算法中，输出到最终结果的顺序按照 Top->Bottom 和 Left->Right，符合前序遍历的顺序。
代码:
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution(object):
def preorderTraversal(self, root):
if root is None:
return []
stack, output = [root], []
while stack:
root = stack.pop()
if root is not None:
output.append(root.val)
if root.right is not None:
stack.append(root.right)
if root.left is not None:
stack.append(root.left)
return output
二叉树中序遍历：
解题思路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 __init__(self):
self.ret = []
def inorderTraversal(self, root):
if not root:
return []
if root.left:
self.inorderTraversal(root.left)
if root.val:
self.ret.append(root.val)
if root.right:
self.inorderTraversal(root.right)
return self.ret
解题思路2: 迭代法
代码:
class Solution(object):
def inorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
res = []
stack = []
while stack or root:
# 不断往左子树方向走，每走一次就将当前节点保存到栈中
# 这是模拟递归的调用
if root:
stack.append(root)
root = root.left
# 当前节点为空，说明左边走到头了，从栈中弹出节点并保存
# 然后转向右边节点，继续上面整个过程
else:
tmp = stack.pop()
res.append(tmp.val)
root = tmp.right
return res
二叉树后序遍历：
解题思路1: 递归法
代码:
class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution(object):
def __init__(self):
self.ret = []
def postorderTraversal(self, root):
if not root:
return []
if root.left:
self.postorderTraversal(root.left)
if root.right:
self.postorderTraversal(root.right)
if root.val:
self.ret.append(root.val)
return self.ret
解题思路2: 迭代法
从根节点开始依次迭代，弹出栈顶元素输出到输出列表中，然后依次压入它的所有孩子节点，按照从上到下、从左至右的顺序依次压入栈中。
因为深度优先搜索后序遍历的顺序是从下到上、从左至右，所以需要将输出列表逆序输出。
代码:
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution(object):
def postorderTraversal(self, root):
if root is None:
return []
stack, output = [root, ], []
while stack:
root = stack.pop()
output.append(root.val)
if root.left is not None:
stack.append(root.left)
if root.right is not None:
stack.append(root.right)
return output[::-1] # 关键在这,我们是从根节点开始以根节点->右->左的方式进栈，那么也就是后序遍历的逆序操作。
二叉树层序遍历：
解题思路1: 递归法
先确认树非空，然后调用递归函数 helper(node, level)，参数是当前节点和节点的层次。程序过程如下：
- 输出列表称为 levels，当前最高层数就是列表的长度 len(levels)。比较访问节点所在的层次 level 和当前最高层次 len(levels) 的大小，如果前者更大就向 levels 添加一个空列表。
- 将当前节点插入到对应层的列表 levels[level] 中。
- 递归非空的子节点：helper(node.left / node.right, level + 1)。
代码:
class Solution:
def levelOrder(self, root):
levels = []
if not root:
return levels
def helper(node, level):
# start the current level
if len(levels) == level:
levels.append([])
# append the current node value
levels[level].append(node.val)
# process child nodes for the next level
if node.left:
helper(node.left, level + 1)
if node.right:
helper(node.right, level + 1)
helper(root, 0)
return levels
解题思路2: 迭代法
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
#层序遍历BFS
class Solution:
def LevelorderTraversal(self, root):
if root is None:
return []
res, cur_level = [], [root]
while cur_level:
temp = []
next_level = []
for i in cur_level:
temp.append(i.val)
if i.left:
next_level.append(i.left)
if i.right:
next_level.append(i.right)
res.append(temp) # 层序遍历每一层都是一个一维数组
cur_level = next_level # 不像之前的pop，这里直接是把每一层的左右子树直接赋值给cur_level.
return res # res的结果形式是类似于：[[...], [...], [...]]
参考链接：
