⼆叉树、BFS、堆、Top K、⼆叉搜索树、模拟、图算法
一、二叉树
二叉树的前序中序后序
二叉树节点定义
为了方便演示，我们先定义一个二叉树节点类。
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right前序遍历
前序遍历的顺序是先访问根节点，再遍历左子树，最后遍历右子树。可以用递归实现前序遍历，也可以用栈来实现。
递归
def preorderTraversal(root: TreeNode) -> List[int]:
res = []
def dfs(node):
if not node:
return
res.append(node.val)
# 先左后右
dfs(node.left)
dfs(node.right)
dfs(root)
return res栈
def preorderTraversal(root: TreeNode) -> List[int]:
if not root:
return []
res = []
stack = [root]
while stack:
node = stack.pop()
res.append(node.val)
if node.right:
stack.append(node.right)
if node.left:
stack.append(node.left)
return res
中序遍历
中序遍历的顺序是先遍历左子树，再访问根节点，最后遍历右子树。同样可以用递归或者栈来实现。
递归
def inorderTraversal(root: TreeNode) -> List[int]:
res = []
def dfs(node):
if not node:
return
# 先左 再访问 最后右
dfs(node.left)
res.append(node.val)
dfs(node.right)
dfs(root)
return res
栈
def inorderTraversal(root: TreeNode) -> List[int]:
if not root:
return []
res = []
stack = []
while stack or root:
while root:
stack.append(root)
root = root.left
node = stack.pop()
res.append(node.val)
root = node.right
return res
后序遍历
后序遍历的顺序是先遍历左子树，再遍历右子树，最后访问根节点。同样可以用递归或者栈来实现。
递归
def postorderTraversal(root: TreeNode) -> List[int]:
res = []
def dfs(node):
if not node:
return
dfs(node.left)
dfs(node.right)
res.append(node.val)
dfs(root)
return res
栈
def postorderTraversal(root: TreeNode) -> List[int]:
if not root:
return []
res = []
stack = [root]
while stack:
node = stack.pop()
res.append(node.val)
if node.left:
stack.append(node.left)
if node.right:
stack.append(node.right)
return res[::-1]
需要注意的是，栈实现后序遍历的时候，先遍历右子树再遍历左子树，然后将结果反转即可。
102. 二叉树的层序遍历
给你二叉树的根节点 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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
if root is None:
return []
ans = []
cur = [root]
while cur:
vals = []
nxt = []
for node in cur:
vals.append(node.val)
if node.left: nxt.append(node.left)
if node.right: nxt.append(node.right)
cur = nxt
ans.append(vals)
return ans优化，使用队列，保证当前cur中只保存待取的节点，那么每次访问完后就剔除队列即可。左出右进（先进先出）
class Solution:
def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
if root is None:
return []
ans = []
q = deque([root])
while q:
vals = []
for _ in range(len(q)):
node = q.popleft()
vals.append(node.val)
if node.left: q.append(node.left)
if node.right: q.append(node.right)
ans.append(vals)
return ans先保存根节点，然后先提取根节点的值，然后只要左右不为空就加到nxt中，待cur中的节点访问完毕后，把新的nxt赋值给cur，继续循环。
103. 二叉树的锯齿形层序遍历
给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
class Solution:
def zigzagLevelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
if root is None:
return []
ans = []
cur = [root]
even = False
while cur:
nxt = []
vals = []
for node in cur:
vals.append(node.val)
if node.left: nxt.append(node.left)
if node.right: nxt.append(node.right)
cur = nxt
# 奇数层不变，偶数层翻转
ans.append(vals[::-1] if even else vals)
even = not even
return ans105. 从前序与中序遍历序列构造二叉树
给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。
class Solution:
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if not preorder or not inorder: # 递归终止条件
return
root = TreeNode(preorder[0]) # 先序为“根左右”，所以根据preorder可以确定root
idx = inorder.index(preorder[0]) # 中序为“左根右”，根据root可以划分出左右子树
# 下面递归对root的左右子树求解即可
root.left = self.buildTree(preorder[1:1 + idx], inorder[:idx])
root.right = self.buildTree(preorder[1 + idx:], inorder[idx + 1:])
return root
