算法入门之树（Python）【初级算法——树】【力扣练习】【蓝桥杯练习】_python 树的练习

---

一、二叉树的最大深度（简单）

题目：
给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明:
叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

返回它的最大深度 3 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-depth-of-binary-tree

分析：
利用深度优先搜索，分别找出左右子树的深度，取大的再加一即可。

代码：

# 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 maxDepth(self, root: Optional[TreeNode]) -> int:
        if root is None:
            return 0
        q = self.maxDepth(root.left)
        p = self.maxDepth(root.right)
        return max(q,p) + 1
1
2
3
4
5
6
7
8
9
10
11
12
13

---

二、验证二叉搜索树（中等）

题目：
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

示例 1：

输入：root = [2,1,3]
输出：true

示例 2：

输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。

提示：
树中节点数目范围在[1, 10^4] 内
-2³¹ <= Node.val <= 2³¹-1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/validate-binary-search-tree

分析：
我们可以利用递归来解决这道题，编写一个递归函数，用来判断该节点的值是否处于 (min,max) 区间，否就返回 False 。
那么可以根据二叉搜索树的性质，在递归左子树时，我们需要把上界 max 改为其父节点的值，因为左子树里所有节点的值均小于它的根节点的值。同理递归右子树时，我们需要把下界 min 改为其父节点的值。

代码：

# 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 isValidBST(self, root: TreeNode) -> bool:
        def f(node,Min = float('-inf'),Max = float(inf)):
            if node is None:
                return True
            val = node.val
            if val >= Max or val <=Min:
                return False
            if not f(node.left,Min,val):
                return False
            if not f(node.right,val,Max):
                return False
            return True
        return f(root)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

---

三、对称二叉树（简单）

题目：
给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：

输入：root = [1,2,2,null,3,null,3]
输出：false

提示：
树中节点数目在范围 [1, 1000] 内
-100 <= Node.val <= 100

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/symmetric-tree

分析：
通过递归遍历左右子树，判断 “左.左” 与 “右.右” 是否相等和 “左.右” 与 “右.左” 是否相等。遇到不相等，或者某一节点没有则返回 False 。

代码：

# 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:
        def f(leftnode,rightnode):
            if leftnode is None and rightnode is None:
                return True
            if leftnode is None or rightnode is None:
                return False
            if leftnode.val != rightnode.val:
                return False
            return f(leftnode.left,rightnode.right) and f(leftnode.right,rightnode.left)
        return f(root.left,root.right)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

---

四、二叉树的层序遍历（中等）

题目：
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：
输入：root = [1]
输出：[[1]]

示例 3：
输入：root = []
输出：[]

提示：
树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal

分析：
定义一个 q 用来存放子节点，ans 用于存放每一层的值，即最后的答案。
当 q 中有值就执行循环，将 q 中节点从头取出并删除，将该节点的值存入 ans ，再把他的子节点从左到右依次存入 q 中。
循环结束返回 ans 即可。

代码：

# 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: TreeNode) -> List[List[int]]:
        if root is None:
            return []
        ans = []
        q = [root]
        while q:
            n = len(q)
            temp = []
            for i in range(n):
                node = q.pop(0)
                temp.append(node.val)
                if node.left is not None:
                    q.append(node.left)
                if node.right is not None:
                    q.append(node.right)
            ans.append(temp)
        return ans
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

---

五、将有序数组转换为二叉搜索树（简单）

题目：
给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

示例 1：

输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

示例 2：

输入：nums = [1,3]
输出：[3,1]
解释：[1,3] 和 [3,1] 都是高度平衡二叉搜索树。

提示：
1 <= nums.length <= 10⁴
-10⁴ <= nums[i] <= 10⁴
nums 按 严格递增 顺序排列

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree

分析：
中序遍历，直接选择中间数字作为根节点即可。

代码：

# 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 sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        if len(nums) == 0: 
            return None
        mid = len(nums)//2
        root = TreeNode(nums[mid])
        root.left = Solution.sortedArrayToBST(self,nums[:mid])
        root.right = Solution.sortedArrayToBST(self,nums[mid + 1:])
        return root
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---