代码随想录算法训练营day22|235. 二叉搜索树的最近公共祖先、701.二叉搜索树中的插入操作、450.删除二叉搜索树中的节点

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

不涉及到遍历顺序，因为二叉树有序，也不需要对二叉树进行处理，只需要有左和右遍历就行了

因为二叉搜索树是有序树，所以如果中间节点是 q 和 p 的公共祖先，那么中节点的数组 一定是在 [p, q]区间的。即 中节点 > p && 中节点 < q 或者 中节点 > q && 中节点 < p。

那么只要从上到下去遍历，遇到 cur节点是数值在[p, q]区间中则一定可以说明该节点cur就是p 和 q的公共祖先。

迭代法：

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

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        while root:
            if root.val>p.val and root.val>q.val:
                root = root.left  
            elif root.val<p.val and root.val<q.val:
                root = root.right 
            else:
                 return root 
                 break
        return None
        

不用使用回溯，二叉搜索树自带方向性，可以方便的从上向下查找目标区间，遇到目标区间内的节点，直接返回。

递归法：

class Solution:
    def traversal(self, cur, p, q):
        if cur is None:
            return cur
                                                        
        if cur.val > p.val and cur.val > q.val:           # 左
            left = self.traversal(cur.left, p, q)
            if left is not None:
                return left

        if cur.val < p.val and cur.val < q.val:           # 右
            right = self.traversal(cur.right, p, q)
            if right is not None:
                return right

        return cur

    def lowestCommonAncestor(self, root, p, q):
        return self.traversal(root, p, q)

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

比较根结点与要插入值的大小关系，判断应该往哪边插入值。

且插入的值都可以在叶子结点插入。 没有考虑左右是否平衡

递归法：

1. 当我们搜索到空结点，这个空结点就是应该插入的值
2. 把这个值返回上去
3. 此时根结点的左孩子或者右孩子就把该值给接收了
4. 最后返回的root就是构建好的二叉树

# 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: Optional[TreeNode], val: int) -> Optional[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

# 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, key):
        #找不到的情况
        if root is None:
            return root 
        #找到
        if root.val == key:
            #左为空右也为空
            if root.left is None and root.right is None:
                return None 
            #左为空右不为空
            elif root.left is None and root.right is not None:
                return root.right 
            #左不为空右为空
            elif root.left is not None and root.right is None:
                return root.left 
            #左不空右也不空 
            else: 
                cur = root.right 
                while cur.left is not None:
                    cur = cur.left 
                cur.left = root.left
                return root.right  
            
        #叉搜索树的递归方法，判断往左还是往右
        #根结点的左右子树接收前面递归传回来的已构建好的二叉树
        if root.val > key:
                root.left = self.deleteNode(root.left,key)
        if root.val<key:
                root.right = self.deleteNode(root.right,key)

        return root
            

def traversal(self,root):
    #返回逻辑
    if root is None:
        return root 
    #其余情况全部列举
    if...
    if...
    
    #递归逻辑
    #只考虑左子树，并接收左孩子传来的结果
    if root.val>key:
        root.left = self.traversal(root.left,key)
    #右边同理
    if root.val<key:
        root.right = self.traversal(root.right,key)
    
    #递归函数返回值
    return root