从二叉树开始刷起（四）—— 二叉搜索树的查找、插入、删除与合法性判断

数据结构的增删改查永远是逃不掉的基本操作，那就从节点的查找开始吧。

700. 二叉搜索树中的搜索

可以直接很暴力地遍历每一个节点进行比较：

class Solution:
    def searchBST(self, root: TreeNode, val: int) -> TreeNode:
        if not root:return None
        if root.val == val:
            return root
        return self.searchBST(root.left,val) or self.searchBST(root.right,val)

或者更优一点的方法，我们可以利用BST的性质，采用二分查找的思想，不断地缩小递归的范围：

class Solution:
    def searchBST(self, root: TreeNode, val: int) -> TreeNode:
        if not root:return None
        if root.val == val: 
            return root
        if val > root.val:
            # 因为是返回被查找节点所在的子树，故需要返回
            return self.searchBST(root.right,val)
        else:
            return self.searchBST(root.left,val)

这基本就可以当作BST遍历的模板来使用了。

def BST(root,target):
	if not root:return
	if target == root.val:
		# do something
	elif target > root.val:
		BST(root.right,target)
	else:
		BST(root.left,target)

我们拿这个模板再来看一下节点的插入：

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

这里其实直接套用模板即可，但是需要注意，当root为空的时候就是元素应该新插入节点的时候；并且需要在递归中更新左右子树：

class Solution:
    def insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:
        if not root: 
            # root为空即为要插入的地方
            return TreeNode(val)
        # val == root.val题目中说不需要考虑
        if val > root.val:
            # 注意：因为是插入元素，即更新树，这里就是更新对应的左右子树
            root.right = self.insertIntoBST(root.right,val)
        elif val < root.val:
            root.left = self.insertIntoBST(root.left,val)
        return root

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

对于这种问题我们先利用框架：

def action_BST(root,key):
    if not root: return
    if root.val == key:
        # do something
    elif root.val > key:
    	action_BST(root.right,key)
    else:
    	action_BST(root.left,key)

基本思路还是按照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 deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
        def get_min(node):
            # BST的最左边就是最小的
            while node.left:
                node = node.left
            return node

        if not root:return
        if root.val == key:
            # 找到了，要执行一堆动作
            # 如果某一边为空则返回另一边，两边都为空也能包住，返回空
            if not root.right:return root.left
            if not root.left: return root.right
            # 对于两边都有子树的情况
            # 先找到右子树中的最小值
            minNode = get_min(root.right)
            # 再让这个最小值顶替掉当前要删除的节点
            root.val = minNode.val
            # 再删除右子树中的那个最小值
            root.right = self.deleteNode(root.right,minNode.val)
        elif key > root.val:
            # 大于根节点，在右子树中递归查找
            root.right = self.deleteNode(root.right,key)
        else:
            # 小于根节点，在左子树中递归查找
            root.left = self.deleteNode(root.left,key)
        return root

最后我们来看一道验证BST的题，也是很经典：

98. 验证二叉搜索树

我可以利用BST的定义来做这道题，但是需要注意参数的传递，不能简单判断根节点的左右子树：

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        def isValid(root,min,max):
            if not root:return True
            if min and root.val <= min.val:return False
            if max and root.val >= max.val:return False

            return isValid(root.left,min,root) and isValid(root.right,root,max)
        return isValid(root,None,None)

或者另一种写法：

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        def isValid(root,min,max):
            if not root:return True
            if min < root.val < max:
                return isValid(root.left,min,root.val) and isValid(root.right,root.val,max)
            else:
                return False
        return isValid(root,-float('inf'),float('inf'))

或者我们也可以利用中序遍历结果是否升序来判断：

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        # 注意初始化的值，不能是0
        self.pre = -float('inf')
        def isValid(root):
            if not root: return True
            l = isValid(root.left)
            if root.val <= self.pre:
                return False
            # 注意更新实际是在判断之后
            self.pre = root.val
            r =  isValid(root.right)
            return l and r
        return isValid(root)

当然还可以用迭代方法实现上述过程：

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        stack, inorder = [], float('-inf')
        
        while stack or root:
            while root:
                stack.append(root)
                root = root.left
            root = stack.pop()
            # 如果中序遍历得到的节点的值小于等于前一个 inorder，说明不是二叉搜索树
            if root.val <= inorder:
                return False
            inorder = root.val
            root = root.right

        return True