前言
所有题目均来自力扣题库中的hot 100，之所以要记录在这里，只是方便后续复习
94.二叉树的中序遍历
题目：
给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。
示例 1：
输入：root = [1,null,2,3]
输出：[1,3,2]
示例 2：
输入：root = []
输出：[]
示例 3：
输入：root = [1]
输出：[1]
解题思路：
【递归】中序遍历即先遍历左节点，再遍历根节点，最后遍历右节点；可采用递归的方法，也可以才使用栈的方法
代码（python）：
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution(object):
def inorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
result = list()
self.test(root, result)
return result
def test(self, root, result):
if not root:
return
# 先遍历左节点，再将根节点的值放入结果，再遍历右节点
self.test(root.left, result)
result.append(root.val)
self.test(root.right, result)
代码（java）：
**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
ArrayList<Integer> array = new ArrayList<>();
// 定义栈
Deque<TreeNode> stack = new LinkedList<>();
// 根节点不为空 或者 栈不为空
while (root != null || ! stack.isEmpty()){
// 先将根节点的左节点全都放入栈（直到左节点为空）
while (root != null){
stack.push(root);
root = root.left;
}
// 弹出节点，将节点加入结果中，再让节点等于右节点（开始迭代右节点）
root = stack.pop();
array.add(root.val);
root = root.right;
}
return array;
知识点：
- 二叉树先序遍历：根节点——左节点——右节点；中序遍历：左节点——根节点——右节点；后序遍历：左节点——右节点——根节点
原题链接：二叉树的中序遍历
101.对称二叉树
题目：
给你一个二叉树的根节点 root ， 检查它是否轴对称。
示例 1：
输入：root = [1,2,2,3,4,4,3]
输出：true
示例 2：
输入：root = [1,2,2,null,3,null,3]
输出：false
解题思路：
【递归】二叉树问题多考虑递归；对称节点规律：左右两个节点都为空则对称；左右两个节点一个为空一个不为空则不对称；两个节点都不为空，判断两个节点值是否相等，且左节点的右子树和右节点的左子数是否对称，且左节点的左子数和右节点的右子树是否对称
代码（python）：
# 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 isSymmetric(self, root: TreeNode) -> bool:
if root is None:
return True
return self.test(root.left, root.right)
def test(self, l, r):
if l is None and r is None:
return True
if l is not None and r is not None:
if l.val != r.val:
return False
else:
return self.test(l.right, r.left) and self.test(l.left, r.right)
else:
return False
代码（java）：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public boolean isSymmetric(TreeNode root) {
return test(root.left, root.right);
}
// 转化为判断左右两个节点是否对称
public boolean test(TreeNode node1, TreeNode node2){
// 如果两个节点都为空则对称
if (node1 == null && node2 == null){
return true;
}
// 如果有一个节点为空，一个节点不为空，则不对称
if (node1 == null || node2 == null){
return false;
}
// 如果两个节点都不为空，判断两个节点值是否相等 且左节点的右子树和右节点的左子数是否对称 且左节点的左子数和右节点的右子树是否对称
return node1.val == node2.val && test(node1.left, node2.right) && test(node1.right, node2.left);
}
}
知识点：
- 无
原题链接：对称二叉树
104.二叉树的最大深度
题目：
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3
/
9 20
/
15 7
返回它的最大深度 3 。
解题思路：
【递归】二叉树的题多考虑递归；可转化为左节点的最大深度 与 右节点的最大深度 的较大值 加上1（即当前根节点），递归的中止条件是 节点为空的情况，最大深度即为0
代码（python）：
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution(object):
def maxDepth(self, root):
"""
:type root: TreeNode
:rtype: int
"""
# 如果当前节点为空 则返回深度为0
if not root:
return 0
# 不为空，则返回左节点的最大深度 和 右节点的最大深度 之中的较大值 再 + 1 （当前节点）
return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1
代码（java）：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int maxDepth(TreeNode root) {
if(root == null){
return 0;
}
return 1 + Math.max(maxDepth(root.right), maxDepth(root.left));
}
}
知识点：
- 无
原题链接：二叉树的最大深度
226.翻转二叉树
题目：
给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
示例 1：
输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]
示例 2：
输入：root = [2,1,3]
输出：[2,3,1]
示例 3：
输入：root = []
输出：[]
解题思路：
【递归】二叉树多考虑递归；先将左节点翻转，再将右节点翻转，最后将两个节点对调即完成了二叉树的翻转；左右两个节点翻转方式是一样的，即递归；递归的中止条件是当前节点为空，直接返回空节点即可
代码（python）：
# 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 invertTree(self, root: TreeNode) -> TreeNode:
if not root:
return
self.invertTree(root.left)
self.invertTree(root.right)
node = root.left
root.left = root.right
root.right = node
return root
代码（java）：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public TreeNode invertTree(TreeNode root) {
// 如果当前节点为空，则直接返回空
if (root == null){
return null;
}
// 先定义一个节点存放 翻转后的左节点
TreeNode node = invertTree(root.left);
// 让左节点等于翻转后的右节点
root.left = invertTree(root.right);
// 让右节点等于之前存放的翻转后的左节点
root.right = node;
//返回根节点即可
return root;
}
}
知识点：
- 无
原题链接：翻转二叉树
543.二叉树的直径
题目：
给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。
示例 :
给定二叉树
1
/ \
2 3
/ \
4 5
返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。
解题思路：
【递归】二叉树多考虑递归；经过当前节点的最多节点数应该是左节点的最大深度（最多节点）+右节点的最大深度（最多节点） + 1，我们可以递归得到左节点和右节点的最大深度，然后再取俩者较大值+ 1 则是当前节点的最大深度，递归的中止条件是当前节点为空，最大深度即为0，但是在这个过程中，我们要记录一个值用来存储经过当前节点的最多节点，并每次都进行比较取得最大值，在我们递归完成根节点取得根节点的最大深度后，也就意味着将经过没给节点的最大节点数都比较完成，最后再返回最大节点数 - 1 即 最大路径
代码（python）：
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution(object):
# 定义结果，表示最长路径经过的节点数
result = 1
def diameterOfBinaryTree(self, root):
"""
:type root: TreeNode
:rtype: int
"""
self.max_depath(root)
# 直径即经过的节点数 - 1
return self.result - 1
def max_depath(self, root):
# 如果节点为空，则返回经过的节点为空
if not root:
return 0
# 递归得到左节点中最大深度（即最长的节点数）
max_left = self.max_depath(root.left)
# 递归得到右节点中最大深度（即最长的节点数）
max_right = self.max_depath(root.right)
# 以当前节点为根节点的情况下，最长路径经过的节点数是左节点的最大深度 + 右节点的最大深度 + 当前节点； 并以此值和结果值比较 ，取较大者赋给结果值
self.result = max(self.result, max_left + max_right + 1)
# 返回当前节点的最大深度，即左右节点的最大神的较大者 + 1（当前节点）
return max(max_left, max_right) + 1
代码（java）：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int result = 0;
public int diameterOfBinaryTree(TreeNode root) {
deep(root);
return result - 1;
}
public int deep(TreeNode root){
if(root == null){
return 0;
}
int leftMax = deep(root.left);
int rightMax = deep(root.right);
result = Math.max(result, leftMax + rightMax + 1);
return Math.max(leftMax, rightMax) + 1;
}
}
知识点：
- 无
原题链接：二叉树的直径
