基础数据结构篇（下）Day11-12

1. 0700. 二叉搜索树中的搜索

1.1 题目大意

描述：给定一个二叉搜索树和一个值 val。

要求：在二叉搜索树中查找节点值等于 val 的节点，并返回该节点。

# 定义一个二叉树节点类
class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        # 初始化节点的值为 val，左右子节点为 left 和 right
        self.val = val
        self.left = left
        self.right = right

# 定义一个解决方案类
class Solution(object):
    # 定义一个搜索二叉搜索树的函数
    def searchBST(self, root, val):
        # 如果当前节点为空或者其值等于目标值，直接返回当前节点
        if root is None or root.val == val:
            return root
        # 如果目标值小于当前节点的值，说明目标值在当前节点的左子树中
        if val < root.val:
            # 递归地在左子树中搜索目标值
            return self.searchBST(root.left, val)
        # 如果目标值大于当前节点的值，说明目标值在当前节点的右子树中
        else:
            # 递归地在右子树中搜索目标值
            return self.searchBST(root.right, val)

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

2.1 题目大意

描述：给定一个二叉搜索树的根节点和要插入树中的值 val。

要求：将 val 插入到二叉搜索树中，返回新的二叉搜索树的根节点。

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 insertIntoBST(self, root, val):
        # 如果根节点为空，说明已经找到了插入的位置，直接创建一个新的节点即可
        if not root:
            return TreeNode(val)
        # 如果新值小于当前节点的值，说明新值应该被插入到当前节点的左子树中
        if val < root.val:
            # 递归地在左子树中插入新值
            root.left = self.insertIntoBST(root.left, val)
        # 如果新值大于当前节点的值，说明新值应该被插入到当前节点的右子树中
        else:
            # 递归地在右子树中插入新值
            root.right = self.insertIntoBST(root.right, val)
        # 返回插入新值后的树的根节点
        return root

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

3.1 题目大意

描述：给定一个二叉搜索树的根节点 root，以及一个值 key。

要求：从二叉搜索树中删除 key 对应的节点。并保证删除后的树仍是二叉搜索树。要求算法时间复杂度为 0(ℎ)，$h$ 为树的高度。最后返回二叉搜索树的根节点。

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 deleteNode(self, root, key):
        # 如果根节点为空，说明树为空，直接返回 None
        if not root:
            return None
        # 如果要删除的节点的值小于当前节点的值，说明要删除的节点在当前节点的左子树中
        if key < root.val:
            # 递归地在左子树中删除节点
            root.left = self.deleteNode(root.left, key)
        # 如果要删除的节点的值大于当前节点的值，说明要删除的节点在当前节点的右子树中
        elif key > root.val:
            # 递归地在右子树中删除节点
            root.right = self.deleteNode(root.right, key)
        # 如果要删除的节点的值等于当前节点的值，说明找到了要删除的节点
        else:
            # 如果当前节点没有左子节点，直接用其右子节点替换当前节点
            if not root.left:
                return root.right
            # 如果当前节点没有右子节点，直接用其左子节点替换当前节点
            elif not root.right:
                return root.left
            # 如果当前节点既有左子节点又有右子节点，需要找到右子树中的最小节点来替换当前节点
            else:
                # 找到右子树中的最小节点
                min_node = self.findMin(root.right)
                # 用最小节点的值替换当前节点的值
                root.val = min_node.val
                # 在右子树中删除最小节点
                root.right = self.deleteNode(root.right, min_node.val)
        # 返回删除节点后的树的根节点
        return root

    def findMin(self, node):
        # 在以 node 为根的子树中找到最小节点
        while node.left:
            node = node.left
        return node

1. 0098. 验证二叉搜索树

1.1 题目大意

描述：给定一个二叉树的根节点 root。

要求：判断其是否是一个有效的二叉搜索树。

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 isValidBST(self, root):
        # 初始化一个栈和一个结果列表
        stack, inorder = [], float('-inf')
        # 当栈不为空或者根节点不为空时，继续循环
        while stack or root:
            # 如果根节点不为空，将其入栈，并移动到左子节点
            while root:
                stack.append(root)
                root = root.left
            # 弹出栈顶元素，即当前节点
            root = stack.pop()
            # 如果当前节点的值小于等于前一个节点的值，说明这不是一个有效的二叉搜索树
            if root.val <= inorder:
                return False
            # 更新前一个节点的值为当前节点的值
            inorder = root.val
            # 移动到右子节点
            root = root.right
        # 如果所有的节点都满足条件，说明这是一个有效的二叉搜索树
        return True

2. 0108. 将有序数组转换为二叉搜索树

2.1 题目大意

描述：给定一个升序的有序数组 nums。

要求：将其转换为一棵高度平衡的二叉搜索树。

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 sortedArrayToBST(self, nums):
        # 如果数组为空，说明已经处理完所有的元素，直接返回 None
        if not nums:
            return None
        # 找到数组的中间元素作为根节点
        mid = len(nums) // 2
        # 创建根节点
        root = TreeNode(nums[mid])
        # 递归地创建左子树和右子树
        root.left = self.sortedArrayToBST(nums[:mid])
        root.right = self.sortedArrayToBST(nums[mid+1:])
        # 返回根节点
        return root

3. 0235. 二叉搜索树的最近公共祖先

3.1 题目大意

描述：给定一个二叉搜索树的根节点 root，以及两个指定节点 p 和 q。

要求：找到该树中两个指定节点的最近公共祖先。

class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        # 如果当前节点为空或者等于p或q，直接返回当前节点
        if root is None or root == p or root == q:
            return root
        # 如果p和q的值都小于当前节点的值，说明p和q都在当前节点的左子树中，向左子树移动
        if p.val < root.val and q.val < root.val:
            return self.lowestCommonAncestor(root.left, p, q)
        # 如果p和q的值都大于当前节点的值，说明p和q都在当前节点的右子树中，向右子树移动
        if p.val > root.val and q.val > root.val:
            return self.lowestCommonAncestor(root.right, p, q)
        # 如果p和q的值一个大于当前节点的值一个小于当前节点的值，说明当前节点就是p和q的最近公共祖先
        return root

二叉搜索树（Binary Search Tree）：也叫做二叉查找树、有序二叉树或者排序二叉树。是指一棵空树或者具有下列性质的二叉树：

• 如果任意节点的左子树不为空，则左子树上所有节点的值均小于它的根节点的值。
• 如果任意节点的右子树不为空，则右子树上所有节点的值均大于它的根节点的值。
• 任意节点的左子树、右子树均为二叉搜索树。