二叉树的遍历
前序遍历
根左右
前序遍历递归写法
class Solution:
def preorderTraversal(self, root: TreeNode) -> List[int]:
res = []
def dfs(node):
if not node:
return
res.append(node.val)
if node.left:
dfs(node.left)
if node.right:
dfs(node.right)
dfs(root)
return res
前序遍历的循环写法
class Solution:
def preorderTraversal(self, root: TreeNode) -> List[int]:
res = []
stack = [root]
while stack:
node = stack.pop() # 从后面pop
if node:
res.append(node.val)
# 如果有处理,这里处理节点
# 因为从后面pop,所以先添加右节点
if node.right:
stack.append(node.right)
if node.left:
stack.append(node.left)
return res
n叉树的前序遍历
递归版本
class Solution:
def preorder(self, root: 'Node') -> List[int]:
res = []
def dfs(node):
if not node:
return
res.append(node.val)
if not node.children:
return
for child in node.children:
dfs(child)
dfs(root)
return res
循环版本
class Solution:
def preorder(self, root: 'Node') -> List[int]:
res = []
if not root:return
stack = [root]
while stack:
node = stack.pop()
res.append(node.val)
if node.children:
stack.extend(node.children[::-1])
return res
备注:如果使用循环写法,使用pop,记得倒序增加节点
层次遍历
class Solution:
def levelOrder(self, root: TreeNode) -> List[List[int]]:
res = []
if not root:return []
stack = [root]
while stack:
next_stack = []
res_tmp = []
while stack:
node = stack.pop(0)
res_tmp.append(node.val)
# 从右往左增加节点
if node.left:
next_stack.append(node.left)
if node.right:
next_stack.append(node.right)
stack = next_stack[:]
res.append(res_tmp)
return res
中序遍历-左右根
递归写法,调整遍历顺序
class Solution:
def inorderTraversal(self, root: TreeNode) -> List[int]:
res = []
def dfs(node):
if not node:
return
if node.left:
dfs(node.left)
res.append(node.val)
if node.right:
dfs(node.right)
dfs(root)
return res
循环写法,调整入栈和出栈顺序
def inorderTraversal(self, root: TreeNode) -> List[int]:
res = []
stack = []
pos = root
if not pos:return []
while pos or stack:
while pos:
stack.append(pos)
pos = pos.left
pos = stack.pop()
# 处理该节点
pos = pos.right
return res
二叉树节点数
递归写法
class Solution:
def countNodes(self, root: TreeNode) -> int:
def count_node(node):
if not node:
return 0
return count_node(node.left) + count_node(node.right) + 1
return count_node(root)
非递归写法
class Solution:
def countNodes(self, root: TreeNode) -> int:
stack = []
pre = None
cur = root
while cur or stack:
while cur:
stack.append(cur)
cur = cur.left
cur = stack.pop()
while cur and (cur.right is None or cur.right==pre):
pre = cur
# 对cur的处理步骤,
if not stack:
return
cur = stack.pop()
stack.append(cur)
cur = cur.right
二叉树深度
class Solution:
def maxDepth(self, root: TreeNode) -> int:
max_depth = 0
def dfs(node,depth):
nonlocal max_depth
if depth > max_depth:
max_depth = depth
if node.left:
dfs(node.left,depth+1)
if node.right:
dfs(node.right,depth+1)
if root:
dfs(root,1)
return max_depth
或者使用层次遍历。