LeetCode 144,94,145,102,103 Binary Tree Traversal 二叉树遍历 Python Solution
这篇文章汇总介绍 LeetCode 上的二叉树的遍历题目，由于内容可能比较多，所以持续更新中ing
1.
首先是 144. Binary Tree Preorder Traversal
二叉树的前序遍历，这里分别给出递归和循环的做法。
思路：
递归，用一个类属性(类似于全局变量)来保存需要返回遍历列表
循环，使用mystack(先入后出的堆)作为辅助结构来储存一些中间信息。
# 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.l = []
def preorderTraversal(self, root):
'''利用递归实现树的前序遍历'''
if root == None:
return []
self.l.append(root.val)
self.preorderTraversal(root.left)
self.preorderTraversal(root.right)
return self.l
def preorderTraversal(self, root):
'''利用循环实现树的前序遍历'''
if root == None:
return []
mystack = []
out = []
cur = root
while cur or myqueue:
while cur:#从根节点開始，一直找它的左子树
mystack.append(cur)
out.append(cur.val)
cur = cur.left
cur = mystack.pop().right #while结束表示当前节点node为空，即前一个节点没有左子树了,開始查看它的右子树
return out
"""
:type root: TreeNode
:rtype: List[int]
"""
2.
接着是94. Binary Tree Inorder Traversal
思路：
递归，用一个类属性(类似于全局变量)来保存需要返回遍历列表
循环，使用mystack(先入后出的堆)作为辅助结构来储存一些中间信息。
# 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.l = []
def inorderTraversal(self, root):
'''利用递归实现树的中序遍历'''
if root == None:
return []
self.inorderTraversal(root.left)
self.l.append(root.val)
self.inorderTraversal(root.right)
return self.l
"""
:type root: TreeNode
:rtype: List[int]
"""
def inorderTraversal(self, root):
'''利用堆栈实现树的中序遍历'''
if root == None:
return []
cur = root
mystack = []
outstack = []
while mystack or cur:
while cur:
mystack.append(cur)
cur = cur.left
tmp = mystack.pop()
outstack.append(tmp.val)
cur = tmp.right
return outstack
"""
:type root: TreeNode
:rtype: List[int]
"""3.
再接着是145. Binary Tree Postorder Traversal
二叉树的后序遍历，这里分别给出递归和循环的做法。
思路：
递归，用一个类属性(类似于全局变量)来保存需要返回遍历列表
循环，这里使用到一个trick,就是后续遍历(左右根)是(根右左的)反转，而根右左的遍历做法和
前序遍历（根左右类似），这样问题就很轻松了。
# 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.l = []
def postorderTraversal(self, root):
if root == None:
return []
self.postorderTraversal(root.left)
self.postorderTraversal(root.right)
self.l.append(root.val)
return self.l
def postorderTraversal(self, root):
if root == None:
return []
cur = root
mystack = []
out = []
while mystack or cur:# 根右左的遍历，类似前序的写法
while cur:
out.append(cur.val)
mystack.append(cur)
cur = cur.right
cur = mystack.pop().left
return out[::-1]#反转后就是左右根
"""
:type root: TreeNode
:rtype: List[int]
"""
4.然后是102. Binary Tree Level Order Traversal
题目要求给出树的层次遍历，值得注意的是要求了返回格式rtype: List[List[int]]，这个格式有别去上面3题要求的
返回格式，所以一定程度上改变了解法和加强的难度。
return its level order traversal as:
[ [3], [9,20], [15,7] ]
这里给出两种解法：
（1）做广度优先遍历BFS，做法就是用一个辅助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 levelOrder(self, root):
res = []
if root == None:
return res
q = [root] #辅助list
while len(q)!=0:
res.append([node.val for node in q])
new_q = []
for node in q:#对于上一层的每一个节点都进行以下操作
if node.left:
new_q.append(node.left)
if node.right:
new_q.append(node.right)
q = new_q
return res
"""
:type root: TreeNode
:rtype: List[List[int]]
"""# 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 dfs(self,root,depth,res):
if root == None:
return res
if len(res) < depth+1:#判断当前节点的深度，进行对应操作
res.append([])
res[depth].append(root.val)
self.dfs(root.left,depth+1,res)
self.dfs(root.right,depth+1,res)
def levelOrder(self, root):
res = []
self.dfs(root,0,res)
return res
"""
:type root: TreeNode
:rtype: List[List[int]]
"""BTW，这里如果该一下返回list的格式问题就简单多了，比如改rtype: List[int]
下面也想前，中，后序遍历一样给出了两种解法，值得注意的是这里用来存储
节点的是先入先出的队列。
# 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.l = []
def levelOrder(self, root):
if root == None:
return []
self.l.append(root.val)
self.levelOrder(root.left)
self.levelOrder(root.right)
return self.l
def levelOrder(self, root):
if root == None:
return []
myqueue = [root]#以队列来存放层次遍历的节点
res = []
while len(myqueue)!=0:
node = myqueue.pop(0)
res.append(node.val)
if node.left:
myqueue.append(node.left)
if node.right:
myqueue.append(node.right)
return res
"""
:type root: TreeNode
:rtype: List[int]
"""5.再着是 103. Binary Tree Zigzag Level Order Traversal
题目要求：
Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).
For example:
Given binary tree [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
return its zigzag level order traversal as:
[ [3], [20,9], [15,7] ]
解法同层次遍历类似，只需要最后对res的部分元素进行重新组织即可：
这里和层次遍历一样提供两种解法：
# 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 dfs(self,root,depth,res):
if root == None:
return res
if len(res) < depth+1:
res.append([])
res[depth].append(root.val)
self.dfs(root.left,depth+1,res)
self.dfs(root.right,depth+1,res)
def zigzagLevelOrder(self, root):
res = []
self.dfs(root,0,res)
for i in range(len(res)):
if i%2 == 1:
res[i] = res[i][::-1]
return res
def zigzagLevelOrder(self, root):
res = []
if root == None:
return res
q = [root]
cnt = 0
while len(q)!=0:
res.append([node.val for node in q])
new_q = []
for node in q:
if node.left:
new_q.append(node.left)
if node.right:
new_q.append(node.right)
q = new_q
for i in range(len(res)):
if i%2==1:
res[i] = res[i][::-1]
return res
"""
:type root: TreeNode
:rtype: List[List[int]]
"""