leetcode系列 - 数据结构 - 2. 树

1. 树的递归问题

1）104：maxDepth数的最大深度（数节点数）

# 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

# count the number of nodes along the longest path from root to any leaf node.
class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if root is None: 
            return 0 
        else: 
            left_height = self.maxDepth(root.left) 
            right_height = self.maxDepth(root.right) 
            return max(left_height, right_height) + 1 # 在当前node所做的就是+1

2）110： isBalanced是否是平衡树

# 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 isBalanced(self, root: TreeNode) -> bool:
        self.isBalanced = True
        if not root:
            return True
        def maxDepth(root: TreeNode) -> int:
            if not root:
                return 0
            leftHeight = maxDepth(root.left)
            rightHeight = maxDepth(root.right)
            if abs(leftHeight - rightHeight) > 1:
                 self.isBalanced = False
            return max(leftHeight, rightHeight) + 1
        
        maxDepth(root)
        return self.isBalanced
        
# 方法二：
class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        def height(root: TreeNode) -> int:
            if not root:
                return 0
            leftHeight = height(root.left)
            rightHeight = height(root.right)
            if leftHeight == -1 or rightHeight == -1 or abs(leftHeight - rightHeight) > 1:
                return -1
            else:
                return max(leftHeight, rightHeight) + 1

        return height(root) >= 0

3）543. maxDiameter

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int max = 0;
    public int diameterOfBinaryTree(TreeNode root) {
        maxDepth(root);
        return max;

    }
    private int maxDepth(TreeNode root){
        if (root == null) return 0;
        int l = maxDepth(root.left); // 左子树的点数（深度）
        int r = maxDepth(root.right); // 右子树的点数（深度）
        // 求当前节点为root的树的周长
        max = Math.max(max, l + r); // （点数之和 +1） 为周长上的所有点数，边数 = 点数之和 +1 - 1 = 点数之和。用它更新max，如果不大于max则不用更新。
        return Math.max(l, r) + 1; // 求当前节点为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

# 关键词：edges，longest path between two nodes, may not pass the root
class Solution:
    def diameterOfBinaryTree(self, root: TreeNode) -> int:
        if not root: return 0
        self.max_diameter = 0
        def depth(root: TreeNode) -> int:
            if not root: return 0
            left_depth = depth(root.left)
            right_depth = depth(root.right)
            self.max_diameter = max(self.max_diameter, left_depth + right_depth)
            return max(left_depth, right_depth) + 1 
        depth(root)
        return self.max_diameter

4）226. invertTree

# 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 None
        temp = root.left
        root.left = self.invertTree(root.right)
        root.right = self.invertTree(temp)
        return root

/**
 * 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 left = root.left;
		root.left = invertTree(root.right);
		root.right = invertTree(left);
		return root;
	}
}

2. 层次遍历（BFS）

使用 BFS 进行层次遍历。不需要使用两个队列来分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。