深搜
前中后序遍历的递归写法:
递归写法很容易,直接给代码
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
res = []
def dfs(root):
if not root:
return
res.append(root.val)
dfs(root.left)
dfs(root.right)
dfs(root)
return res
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
res = []
def dfs(root):
if not root:
return
dfs(root.left)
res.append(root.val)
dfs(root.right)
dfs(root)
return res
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
res = []
def dfs(root):
if not root:
return
dfs(root.left)
dfs(root.right)
res.append(root.val)
dfs(root)
return res
前中后序遍历的迭代写法:
深搜迭代就是模拟堆栈。
前序:
首先root进栈,每次循环弹出栈顶元素,记录值并将左右子树进栈,这里要注意先压右子树再压左子树。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
res = []
if not root:
return []
stack = [root]
while stack:
cur = stack.pop()
res.append(cur.val)
if cur.right:
stack.append(cur.right)
if cur.left:
stack.append(cur.left)
return res
中序:
中序麻烦就麻烦在发现一个节点的时候并不记录他的值,而是从左边返回这个节点的时候再记录值。实际上访问顺序还是一样的都是深搜,代码中需要显式表示“从左边返回”即可。
自己先写一版:
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
def isNext(pre, cur):
if pre and cur.left:
cur = cur.left
while cur.right:
cur = cur.right
if cur == pre:
return True
return False
res = []
if not root:
return []
stack = [root]
pre = None
while stack:
cur = stack[-1]
if isNext(pre, cur):
res.append(cur.val)
pre = stack.pop()
else:
while cur.left:
stack.append(cur.left)
cur = cur.left
res.append(cur.val)
pre = stack.pop()
if cur.right:
stack.append(cur.right)
return res
这份代码能AC, 但是实在是臃肿。看一下题解解法,优化一下自己的思路。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
res = []
stack = []
cur = root
if not root:
return []
while cur or stack:
while cur:
stack.append(cur)
cur = cur.left
cur = stack.pop()
res.append(cur.val)
cur = cur.right
return res
优化:题解方法中,只使用一个cur指针即可。每个循环开始时,一直找左子树的最左边的空,这时候回头查看栈顶,栈顶元素就是中。随后把cur指向中的右,如果右是个空,则直接取栈顶,也就是模拟返回,否则在右子树中继续找左。
这个模拟更加简洁,有点难想到。
后序:
直接反转有点trivial,这里仿照中序硬写一版。
class Solution:
def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
res = []
if not root:
return []
stack = []
cur = root
pre = None
while cur or stack:
while cur:
stack.append(cur)
cur = cur.left
top = stack[-1]
if top.right and top.right != pre:
cur = top.right
else:
stack.pop()
res.append(top.val)
pre = top
return res
统一迭代:
标记法,分为空标记和布尔标记。
空标记:
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
res = []
if not root:
return []
stack = [root]
while stack:
node = stack[-1]
if node != None:
stack.pop()
if node.right:
stack.append(node.right)
stack.append(node)
stack.append(None)
if node.left:
stack.append(node.left)
else:
stack.pop()
res.append(stack.pop().val)
return res
布尔标记:
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
res = []
if not root:
return []
stack = [(root, 0)]
while stack:
node = stack[-1]
if node[1]:
stack.pop()
res.append(node[0].val)
else:
stack.pop()
if node[0].right:
stack.append((node[0].right, 0))
stack.append((node[0], 1))
if node[0].left:
stack.append((node[0].left, 0))
return res
广搜
很基础,使用队列。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
from collections import deque
res = []
if not root:
return []
que = deque([root])
while que:
level = []
for i in range(len(que)):
cur = que.popleft()
level.append(cur.val)
if cur.left:
que.append(cur.left)
if cur.right:
que.append(cur.right)
res.append(level)
return res
1130

被折叠的 条评论
为什么被折叠?



