D22|二叉搜索树 part3

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

1.题目
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。235. 二叉搜索树的最近公共祖先
2.实现
只记得普通的怎么写，没有联想到BST作为有序数组，其公共祖先的特点

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def __init__(self):
        self.res = None

    def lowest(self, root, p, q):
        if not root or self.res:
            return 
        if root.val >= p.val and root.val <= q.val:
            self.res = root
            return
        self.lowest(root.left, p, q)
        self.lowest(root.right, p, q)


    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        # 普通二叉树寻找最近祖先的方法
        # if not root or root == p or root == q:
        #     return root
        # left = self.lowestCommonAncestor(root.left, p, q)
        # right = self.lowestCommonAncestor(root.right, p, q)
        # if left and right:
        #     return root
        # elif left and not right:
        #     return left
        # elif right and not left:
        #     return right
        # else:
        #     return None

        # 利用二叉树有序的特点，去找最近公共祖先的大小特点
        # 利用有序的特点可以不管遍历顺序，通过p q的大小去确定访问哪一边！！
        if p and q:
            if p.val > q.val:
                tmp = p
                p = q
                q = tmp
        elif p and not q:
            return p
        else:
            return q
        self.lowest(root, p, q)
        return self.res

3.文章讲解
可以试试迭代法
对于简单的结论推导，可以利用反证法来证明思路的正确性

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

1.题目
给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。 701.二叉搜索树中的插入操作
2.实现
轻松搞定，还做了优化

# 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 insertnode(self, root, val):
        if not root:
            return TreeNode(val)
        if root.val > val:
            root.left = self.insertnode(root.left, val)
        if root.val < val:
            root.right = self.insertnode(root.right, val)
        return root

    def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        # cur = root
        # self.insertnode(cur, val)
        # if not root:
        #     return TreeNode(val)
        # return root
        return self.insertnode(root, val)

3.文章讲解

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

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]:
        # 查找节点，找到后如为叶子节点不需要动  如有空的左或右子节点，直接让非空值替补（return left or right 存在一个为空的情况）  如都不为空，则随机选一个替补，则对下面的节点出现类似的情况继续递归
        # 如果两节点都存在，需遵循中序遍历
        if not root:
            return root
        if root.val > key:
            root.left = self.deleteNode(root.left, key)
        elif root.val < key:
            root.right = self.deleteNode(root.right, key)
        else:
            if not root.left:
                return root.right
            elif not root.right:
                return root.left
            else:
                tmp = root.right
                tmp2 = tmp
                while tmp.left:
                    tmp = tmp.left
                tmp.left = root.left
                return tmp2
        return root       

总结：
1.画图去理解思路
2.对于普通二叉树如何删除节点呢！可以试试哦！