LeetCode Hot100 刷题笔记（4）—— 二叉树、图论
目录
一、二叉树
1. 二叉树的深度遍历（DFS：前序、中序、后序遍历）
2. 二叉树的最大深度
3. 翻转二叉树
4. 对称二叉树
5. 二叉树的直径
6. 二叉树的层序遍历
7. 将有序数组转换为二叉搜索树
8. 验证二叉搜索树
9. 二叉搜索树中第 K 小的元素
10. 二叉树的右视图
（待更...）
二、图论（待更...）
前言
一、二叉树：二叉树的中序遍历，二叉树的最大深度，翻转二叉树，对称二叉树，二叉树的直径，二叉树的层序遍历，将有序数组转换为二叉搜索树，验证二叉搜索树，二叉搜索树中第 K 小的元素，二叉树的右视图...... (日更ing)
二、图论：...... (日更ing)
一、二叉树
1. 二叉树的深度遍历（DFS：前序、中序、后序遍历）
原题链接：94. 二叉树的中序遍历 - 力扣（LeetCode）
# （1）前序遍历：根-左-右
class Solution(object):
def preorderTraversal(self, root):
res = []
def preorder(root):
if not root:
return
res.append(root.val)
preorder(root.left)
preorder(root.right)
preorder(root)
return res# （2）中序遍历：左-根-右
class Solution(object):
def inorderTraversal(self, root):
res = []
def inorder(root):
if not root:
return
inorder(root.left)
res.append(root.val)
inorder(root.right)
inorder(root)
return res# （3）后序遍历：左-右-根
class Solution(object):
def postorderTraversal(self, root):
res = []
def inorder(root):
if not root:
return
postorder(root.left)
postorder(root.right)
res.append(root.val)
postorder(root)
return res2. 二叉树的最大深度
原题链接：104. 二叉树的最大深度 - 力扣（LeetCode）
class Solution(object):
def maxDepth(self, root):
if not root:
return 0
left_height = self.maxDepth(root.left)
right_height = self.maxDepth(root.right)
return max(left_height, right_height) + 13. 翻转二叉树
原题链接：226. 翻转二叉树 - 力扣（LeetCode）
class Solution(object):
def invertTree(self, root):
if not root:
return
root.left, root.right = root.right, root.left
self.invertTree(root.left)
self.invertTree(root.right)
return root4. 对称二叉树
原题链接：101. 对称二叉树 - 力扣（LeetCode）
class Solution(object):
def isSymmetric(self, root):
def check(left, right):
if not left and not right:
return True
if not left or not right:
return False
if left.val != right.val:
return False
return check(left.left, right.right) and check(left.right, right.left)
return check(root.left, root.right)5. 二叉树的直径
原题链接：543. 二叉树的直径 - 力扣（LeetCode）
class Solution(object):
def diameterOfBinaryTree(self, root):
def dfs(root):
if not root:
return 0, 0
ld, ldepth = dfs(root.left)
rd, rdepth = dfs(root.right)
return max(ld, rd, ldepth+rdepth), max(ldepth, rdepth) + 1
return dfs(root)[0]6. 二叉树的层序遍历
原题链接：102. 二叉树的层序遍历 - 力扣（LeetCode）
class Solution(object):
def levelOrder(self, root):
if not root:
return []
node = [root]
res = []
while len(node) > 0:
res.append([i.val for i in node])
node2 = []
for i in node:
if i.left:
node2.append(i.left)
if i.right:
node2.append(i.right)
node = node2
return res7. 将有序数组转换为二叉搜索树
原题链接：108. 将有序数组转换为二叉搜索树 - 力扣（LeetCode）
class Solution(object):
def sortedArrayToBST(self, nums):
def dfs(left, right):
if left > right:
return
mid = (left + right) // 2
root = TreeNode(nums[mid])
root.left = dfs(left, mid-1)
root.right = dfs(mid+1, right)
return root
return dfs(0, len(nums)-1)8. 验证二叉搜索树
原题链接：98. 验证二叉搜索树 - 力扣（LeetCode）
class Solution(object):
def isValidBST(self, root, left=float('-inf'), right=float('inf')):
if not root:
return True
x = root.val
return left < x < right and self.isValidBST(root.left, left, x) and self.isValidBST(root.right, x, right)
# self.isValidBST(root.left, left, x)：遍历左子树，右边界更新
# self.isValidBST(root.right, x, right)：遍历右子树，左边界更新9. 二叉搜索树中第 K 小的元素
原题链接：230. 二叉搜索树中第 K 小的元素 - 力扣（LeetCode）
# 先通过前序/中序/后序遍历转为list，而后利用list属性找第k个小的元素。
# 此代码使用前序遍历（根-左-右）
class Solution(object):
def kthSmallest(self, root, k):
res = []
def preorder(root):
if not root:
return
res.append(root.val)
preorder(root.left)
preorder(root.right)
return res
res = preorder(root)
res.sort()
return res[k-1]10. 二叉树的右视图
原题链接：199. 二叉树的右视图 - 力扣（LeetCode）
class Solution(object):
def rightSideView(self, root):
# if len(res) == depth: res.append(root.val)
# 先遍历右子树，再遍历左子树
res = []
def dfs(root, depth):
if not root:
return []
if len(res) == depth:
res.append(root.val)
dfs(root.right, depth+1)
dfs(root.left, depth+1)
return res
return dfs(root, 0)