leetcode 专题：树 python 版（持续更新中）
目录
二叉树的基础知识：
二叉树的遍历：
二叉搜索树：
堆：
红黑树：
Leetcode
100 相同的树
101 对称二叉树
104 二叉树的最大深度
107 二叉树的层次遍历 ||
108 将有序数组转换为二叉搜索树
110 平衡二叉树
111 二叉树的最小深度
112 路径总和
226 翻转二叉树
235 二叉搜索树的最近公共祖先
257 二叉树的所有路径
目录
二叉树的基础知识：
二叉树的遍历：
二叉搜索树：
堆：
红黑树：
Leetcode
100 相同的树
101 对称二叉树
二叉树的基础知识：
二叉树的遍历：
前序遍历：根节点，左子节点，右子节点
中序遍历：左子节点，根节点， 右子节点
后序遍历：左子节点，右子节点，根节点
深度优先遍历：先访问数的第一层节点，然后第二层，一直到最后一层。每一层中，从左到右访问。
二叉搜索树：
左子结点总是小于等于根节点，右子节点总是大于等于根节点。
堆：
最大堆：根节点最大
最小堆：根节点最小
红黑树：
树中的节点定义为红、黑两种颜色，通过规则确保从根节点到叶节点的最长路径长度不超过最短路径的两倍。
Leetcode
100 相同的树
给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
示例 1:
输入: 1 1
/ \ / \
2 3 2 3
[1,2,3], [1,2,3]
输出: true示例 2:
输入: 1 1
/ \
2 2
[1,2], [1,null,2]
输出: false
示例 3:
输入: 1 1
/ \ / \
2 1 1 2
[1,2,1], [1,1,2]
输出: false
思路：递归
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
if not p and not q:
return True
if p and q and p.val==q.val:
return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
else:
return False
101 对称二叉树
给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
1
/ \
2 2
/ \ / \
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1
/ \
2 2
\ \
3 3
说明:
如果你可以运用递归和迭代两种方法解决这个问题，会很加分。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def isSymmetric(self, root: TreeNode) -> bool:
if not root:
return True
return self.isSymmetricCore(root.left, root.right)
def isSymmetricCore(self, pleft, pright):
if not pleft and not pright:
return True
if not pleft or not pright:
return False
if pleft.val == pright.val:
return self.isSymmetricCore(pleft.left, pright.right) and self.isSymmetricCore(pleft.right, pright.left)
else:
return False104 二叉树的最大深度
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3
/ \
9 20
/ \
15 7
返回它的最大深度 3 。
思路：递归
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def maxDepth(self, root: TreeNode) -> int:
if not root:
return 0
return max(self.maxDepth(root.right)+1, self.maxDepth(root.left)+1)107 二叉树的层次遍历 ||
给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
例如：
给定二叉树 [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回其自底向上的层次遍历为：
[ [15,7], [9,20], [3] ]
思路：递归
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def __init__(self):
self.result = []
def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
if not root:
return []
node_list = []
node_list.append(root)
self.recursion(node_list)
return self.result[::-1]
def recursion(self, node_list):
if not node_list:
return
res = []
tmp_node_list = []
for node in node_list:
res.append(node.val)
if node.left:
tmp_node_list.append(node.left)
if node.right:
tmp_node_list.append(node.right)
self.result.append(res)
self.recursion(tmp_node_list)
108 将有序数组转换为二叉搜索树
将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。
本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。
示例:
给定有序数组: [-10,-3,0,5,9],
一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：
0
/ \
-3 9
/ /
-10 5
思路：分治
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
if not nums:
return None
mid = len(nums)//2
left = nums[0:mid]
right = nums[mid+1::]
root = TreeNode(nums[mid])
root.left = self.sortedArrayToBST(left)
root.right = self.sortedArrayToBST(right)
return root110 平衡二叉树
给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。
示例 1:
给定二叉树 [3,9,20,null,null,15,7]
3
/ \
9 20
/ \
15 7
返回 true 。
示例 2:
给定二叉树 [1,2,2,3,3,null,null,4,4]
1
/ \
2 2
/ \
3 3
/ \
4 4
返回 false 。
思路：每一个节点都算深度的化太麻烦了，直接递归比较每一个节点是否满足就好。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def isBalanced(self, root: TreeNode) -> bool:
if not root:
return True
return self.IsBalanceCore(root)>=0
def IsBalanceCore(self, root):
if not root:
return 0
left = self.IsBalanceCore(root.left)
right = self.IsBalanceCore(root.right)
if left < 0 or right < 0 or abs(left-right)>1:
return -1
else:
return 1 + max(left, right)
111 二叉树的最小深度
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明: 叶子节点是指没有子节点的节点。
示例:
给定二叉树 [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回它的最小深度 2.
思路：递归
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def minDepth(self, root: TreeNode) -> int:
if not root:
return 0
if root.left and root.right:
return 1 + min(self.minDepth(root.left), self.minDepth(root.right))
elif root.left:
return 1 + self.minDepth(root.left)
elif root.right:
return 1 + self.minDepth(root.right)
else:
return 1112 路径总和
定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。
说明: 叶子节点是指没有子节点的节点。
示例:
给定如下二叉树，以及目标和 sum = 22，
5
/ \
4 8
/ / \
11 13 4
/ \ \
7 2 1
返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。
思路：递归
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def hasPathSum(self, root: TreeNode, nsum: int) -> bool:
if not root:
return False
if not root.left and not root.right:
if nsum == root.val:
return True
else:
return False
return self.hasPathSum(root.left, nsum-root.val) or self.hasPathSum(root.right, nsum-root.val)
226 翻转二叉树
翻转一棵二叉树。
示例：
输入：
4 / \ 2 7 / \ / \ 1 3 6 9
输出：
4 / \ 7 2 / \ / \ 9 6 3 1
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def invertTree(self, root: TreeNode) -> TreeNode:
if not root:
return None
tmp = root.left
root.left = self.invertTree(root.right)
root.right = self.invertTree(tmp)
return root
235 二叉搜索树的最近公共祖先
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]
示例 1:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 输出: 6 解释: 节点2和节点8的最近公共祖先是6。
示例 2:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 输出: 2 解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。
思路：若p、q分别在某一节点的左右子树内，则该节点为最小公共祖先。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
max_node = max(p.val, q.val)
min_node = min(p.val, q.val)
while root:
if root.val <= max_node and root.val >= min_node:
return root
elif root.val > max_node:
root = root.left
else:
root = root.right
257 二叉树的所有路径
给定一个二叉树，返回所有从根节点到叶子节点的路径。
说明: 叶子节点是指没有子节点的节点。
示例:
输入: 1 / \ 2 3 \ 5 输出: ["1->2->5", "1->3"] 解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3
深度优先遍历
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def binaryTreePaths(self, root: TreeNode) -> List[str]:
if not root:
return []
paths = []
if not root.left and not root.right:
return [str(root.val)]
if root.left:
for i in self.binaryTreePaths(root.left):
paths.append(str(root.val) + '->' + i)
if root.right:
for j in self.binaryTreePaths(root.right):
paths.append(str(root.val) + '->' + j)
return paths
404 左叶子之和
计算给定二叉树的所有左叶子之和。
示例：
3
/ \
9 20
/ \
15 7
在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def sumOfLeftLeaves(self, root: TreeNode) -> int:
if not root:
return 0
if root.left and not root.left.left and not root.left.right:
return root.left.val + self.sumOfLeftLeaves(root.right)
else:
return self.sumOfLeftLeaves(root.left) + self.sumOfLeftLeaves(root.right)437 路径总和 |||
给定一个二叉树，它的每个结点都存放着一个整数值。
找出路径和等于给定数值的路径总数。
路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。
二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。
示例：
root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
10
/ \
5 -3
/ \ \
3 2 11
/ \ \
3 -2 1
返回 3。和等于 8 的路径有:
1. 5 -> 3
2. 5 -> 2 -> 1
3. -3 -> 11
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def __init__(self):
self.pathnum = 0
def pathSum(self, root: TreeNode, res: int) -> int:
if not root:
return 0
self.mysum(root, res)
self.pathSum(root.left, res)
self.pathSum(root.right, res)
return self.pathnum
def mysum(self, root: TreeNode, res):
if not root:
return 0
res -= root.val
if res == 0:
self.pathnum += 1
self.mysum(root.left, res)
self.mysum(root.right, res)501 二叉树搜索树中的众数
给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。
假定 BST 有如下定义：
- 结点左子树中所含结点的值小于等于当前结点的值
- 结点右子树中所含结点的值大于等于当前结点的值
- 左子树和右子树都是二叉搜索树
例如：
给定 BST [1,null,2,2],
1
\
2
/
2
返回[2].
提示：如果众数超过1个，不需考虑输出顺序
进阶：你可以不使用额外的空间吗？（假设由递归产生的隐式调用栈的开销不被计算在内）
·