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

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

题目链接：235. 二叉搜索树的最近公共祖先
文档讲解： 代码随想录

这道题和上一题寻找最近公共祖先，不一样的地方在于，这道题是二叉搜索树，二叉搜索树的特点是有序。如果中间节点是公共祖先，那么中节点的数值一定在区间 [p,q] 内。那么从上至下遍历，遇到的第一个在区间的节点，就是最近公共祖先。

递归法：
（1）输入输出：输入节点，输出节点
（2）终止条件：节点为空
（3）单层逻辑：因为不确定 p 和 q 的大小关系，因此，若节点值大于 p 和 q 的值，则往左子树搜索，若都小于则往右子树搜索。

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return root
        if root.val > p.val and root.val > q.val:
            left = self.lowestCommonAncestor(root.left, p, q)
            if left:
                return left
        if root.val < p.val and root.val < q.val:
            right = self.lowestCommonAncestor(root.right, p, q)
            if right:
                return right
        return root

精简版：

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        if root.val > p.val and root.val > q.val:
            return self.lowestCommonAncestor(root.left, p, q)
        elif root.val < p.val and root.val < q.val:
            return self.lowestCommonAncestor(root.right, p, q)
        else:
            return root

迭代法：因为有序，所以直接搜索对应区间就行

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        cur = root
        while cur:
            if cur.val > p.val and cur.val > q.val:
                cur = cur.left
            elif cur.val < p.val and cur.val < q.val:
                cur = cur.right
            else:
                return cur
        return None

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

题目链接：701. 二叉搜索树中的插入操作
文档讲解： 代码随想录

可以不考虑题目中说的改变树结构的插入方式，二叉搜索树是有序的，遍历遇到空节点插入就可以了，因为题目中已经说明了二叉搜索树中的元素值和插入值都是独一无二的。

class Solution(object):
    def __init__(self):
        self.parent = None

    def insertIntoBST(self, root, val):
        """
        :type root: TreeNode
        :type val: int
        :rtype: TreeNode
        """
        if not root:
            return TreeNode(val)
        self.parent = None
        self.traversal(root, val)
        return root

    def traversal(self, cur, val):
        if cur is None:
            node = TreeNode(val)
            if val > self.parent.val:
                self.parent.right = node
            else:
                self.parent.left = node
            return
        self.parent = cur
        if val < cur.val:
            self.traversal(cur.left, val)
        if val > cur.val:
            self.traversal(cur.right, val)

class Solution(object):
    def insertIntoBST(self, root, val):
        """
        :type root: TreeNode
        :type val: int
        :rtype: TreeNode
        """
        if not root:
            return TreeNode(val)
        
        if val < root.val:
            if not root.left:
                root.left = TreeNode(val)
            else:
                self.insertIntoBST(root.left, val)
        elif val > root.val:
            if not root.right:
                root.right = TreeNode(val)
            else:
                self.insertIntoBST(root.right, val)
        return root

class Solution(object):
    def insertIntoBST(self, root, val):
        """
        :type root: TreeNode
        :type val: int
        :rtype: 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

迭代法：

class Solution(object):
    def insertIntoBST(self, root, val):
        """
        :type root: TreeNode
        :type val: int
        :rtype: TreeNode
        """
        #终止条件：遍历到空节点，新建节点返回
        if not root:
            return TreeNode(val)
        
        parent = None
        cur = root
        while cur:
            parent = cur
            #寻找插入点
            if val < cur.val:
                cur = cur.left
            else:
                cur = cur.right
        #此时cur为空
        node = TreeNode(val)
        if val < parent.val:
            parent.left = node
        if val > parent.val:
            parent.right = node
        return root

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

题目链接：450.删除二叉搜索树中的节点
文档讲解： 代码随想录

class Solution(object):
    def deleteNode(self, root, key):
        """
        :type root: TreeNode
        :type key: int
        :rtype: TreeNode
        """
        #递归法
        #终止条件
        #五种情况
        if not root:
            #没找到key
            return root
        if root.val == key:
            if not root.left and not root.right:
                #叶子节点
                return None
            elif not root.right:
                #左不空右空
                return root.left
            elif not root.left:
                #不能写root.right存在，因为左右都不为空的情况也包含在里面
                #左空右不空
                return root.right
            else:
                #左右都不空
                cur = root.right
                while cur.left:
                    cur = cur.left
                cur.left = root.left
                return root.right

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

迭代法：

class Solution(object):
    def deleteNode(self, root, key):
        """
        :type root: TreeNode
        :type key: int
        :rtype: TreeNode
        """
        if not root:
            return root
        cur = root
        pre = None
        while cur:
            if cur.val == key:
                break
            #记录前一个节点
            pre = cur
            if key < cur.val:
                cur = cur.left
            else:
                cur = cur.right
        if not pre:
            #删除的是根节点
            return self.deleteTarget(cur)
        #需要知道删除的是左节点还是右节点
        if pre.left and pre.left.val == key:
            pre.left = self.deleteTarget(cur)
        if pre.right and pre.right.val == key:
            pre.right = self.deleteTarget(cur)
        return root        
        
    def deleteTarget(self, target):
        if not target:
            return target
        if not target.right:
            return target.left
        #将左子树移到右子树的最左边
        cur = target.right
        while cur.left:
            cur = cur.left
        cur.left = target.left
        #移动好，返回右子树根节点
        return target.right

普通二叉树的解法，没有利用二叉搜索树的特性，用交换值的操作来删除节点。代码中的目标节点被操作了两次：
（1）第一次，是和目标节点的右子树的最左面的节点做交换
（2）第二次直接被None替代

class Solution(object):
    def deleteNode(self, root, key):
        """
        :type root: TreeNode
        :type key: int
        :rtype: TreeNode
        """
        if not root:
            return root
        if root.val == key:
            if not root.right:
                return root.left
            cur = root.right
            while cur.left:
                cur = cur.left
            root.val, cur.val = cur.val, root.val
        root.left = self.deleteNode(root.left, key)
        root.right = self.deleteNode(root.right, key)
        return root