二叉搜索树相关题目总结（一） 力扣 Python

总结一下与二叉搜索树有关的题目，解决思路都是二叉搜索树的相关操作。

98. 验证二叉搜索树

解题思路：

验证一颗树是不是二叉搜索树（BST）？

依据二叉搜索树的性质写出代码，如下注释。

# 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: Optional[TreeNode]) -> bool:
        return self.check(root)

    def check(self, root, min_val = float('-inf'), max_val = float('inf')) -> bool:

        # 默认为True
        if not root:
            return True
        #一旦当前节点比最小值小，或者比最大值大，就不是二叉搜索树
        if root.val <= min_val or root.val >= max_val:
            return False
        
        #分别检查左子树和右子树
        return self.check(root.left, min_val, root.val) and self.check(root.right, root.val, max_val)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

700. 二叉搜索树中的搜索

解题思路：
利用 BST 的特性，进行搜索。

如果当前节点小于目标值就去右子树查找。

如果当前节点大于目标值就去左子树查找。

# 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 searchBST(self, root: TreeNode, val: int) -> TreeNode:
        if not root:
            return None

        #利用二叉搜索树的性质，查找 val
        if val < root.val:
            return self.searchBST(root.left, val)
        if val > root.val:
            return self.searchBST(root.right, val)

        return root
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

701. 二叉搜索树中的插入操作

解题思路：

在二叉搜索树查找的基础上，修改相关代码变差插入。

# 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 insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:
        #找到空位置插入新节点
        if not root:
            return TreeNode(val)

        # 对递归调用的返回值进行接收
        if val < root.val:
            root.left = self.insertIntoBST(root.left, val)
            
        if val > root.val:
            root.right = self.insertIntoBST(root.right, val)
            
        return root
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

450. 删除二叉搜索树中的节点

解题思路：

BST 的删除要比前面的三道题复杂一些。

主要是被删除的节点在树中有三种情况。

• 情况1，当前节点没有子节点，直接删除。
• 情况2，当前节点有一个左子节点或右子节点，删除当前节点，并用存在的子节点接替当前子节点。
• 情况3，当前节点右两个子节点，删除当前节点，用左子节点中最大的节点的来接替，或用右子节点中最小的来接替。

# 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 deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:

        if not root:
            return None

        
        if root.val > key:
            root.left = self.deleteNode(root.left, key)
        elif root.val < key:
            root.right = self.deleteNode(root.right, key)

        #找到节点值为 key
        else:
            
            #处理情况 1， 2
            if not root.left:
                return root.right
            if not root.right:
                return root.left

            #处理情况3,这里使用右子树中最小的来接替

            minNode = self.getMin(root.right)

            # 删除右子树中最小的节点
            root.right = self.deleteNode(root.right, minNode.val)

            #替换节点
            minNode.left, minNode.right = root.left, root.right
            root = minNode
            
        return root

    def getMin(self, root):
        #根据BST的性质，最左边的就是最小的
        while root.left:
            root = root.left
        return root
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46