研习代码 day19 |二叉树的递归进阶篇_n-1

一、二叉搜索树的最近公共祖先

        1.1 题目

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉搜索树:  root = [6,2,8,0,4,7,9,null,null,3,5]

示例 1:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6 
解释: 节点 2 和节点 8 的最近公共祖先是 6。

示例 2:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

说明:

• 所有节点的值都是唯一的。
• p、q 为不同节点且均存在于给定的二叉搜索树中。

        1.2 题目链接

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

        1.3 解题思路和过程想法

        （1）解题思路

        1）普通树的处理方法
        因为需要根据左右子树的情况找公共祖先，必然是用后序遍历——左右根。
        # 递归函数是否需要返回值——需要，因为找到指定节点即可结束遍历，返回结果。
        # 递归的出口很好想——遇到空节点或找到指定节点
        # 递归的处理细节，最终结果是：回溯过程中第一个拥有两个指定节点的根节点（当两指定节点在两棵子树上时），或仅有一方节点的该节点（当有一指定节点是另一指定节点的根节点时）
        2）结合搜索树特性的处理方法
        二叉搜索树：最近公共祖先就是从上往下遍历，第一个介于[p.val,q.val]的节点---根左右
        # 递归函数是否需要返回值——需要，因为找到指定节点即可结束遍历，返回结果。
        # 递归的出口很好想——当前值介于[p.val,q.val]
        # 递归的处理细节：当前值小于最小值，则继续往右；大于最大值，则继续往左

        （2）过程想法

        结合搜索树特性所提出的解决方法效率是很高的，但需要 get 到那个点。

        1.4 代码

        1.4.1 普通树的处理方法

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        # 普通二叉树：左右根

        # exit
        if not root or root == p or root == q:
            return root

        # left
        left = self.lowestCommonAncestor(root.left,p,q)

        # right
        right = self.lowestCommonAncestor(root.right,p,q)

        # root
        if left and right:
            return root
        elif left and not right:
            return left
        elif right and not left:
            return right
        else:
            return None

        1.4.2 结合搜索树特性的处理方法

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        # 二叉搜索树：最近公共祖先就是从上往下遍历，第一个介于[p.val,q.val]的节点---根左右

        # 递归出口
        if not root:
            return None

        # 根：当前数介于[p.val,q.val]之间，则直接返回该节点
        if root.val >= min(p.val,q.val) and root.val <= max(p.val,q.val):
            return root
        
        # 左：若当前节点的数大于指定节点中的最大值，则向左遍历
        if root.val > max(p.val,q.val):
            return self.lowestCommonAncestor(root.left,p,q)

        # 右：若当前节点的数小于指定节点中的最小值，则向右遍历
        if root.val < min(p.val,q.val):
            return self.lowestCommonAncestor(root.right,p,q)

二、二叉搜索树中的插入操作

        2.1 题目

给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。

注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。

示例 1：

输入：root = [4,2,7,1,3], val = 5
输出：[4,2,7,1,3,5]
解释：另一个满足题目要求可以通过的树是：

示例 2：

输入：root = [40,20,60,10,30,50,70], val = 25
输出：[40,20,60,10,30,50,70,null,null,25]

示例 3：

输入：root = [4,2,7,1,3,null,null,null,null,null,null], val = 5
输出：[4,2,7,1,3,5]

提示：

• 树中的节点数将在 [0, 10^4]的范围内。
• -10^8 <= Node.val <= 10^8
• 所有值 Node.val 是 独一无二 的。
• -10^8 <= val <= 10^8
• 保证 val 在原始BST中不存在。

        2.2 题目链接

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

        2.3 解题思路和过程想法

        （1）解题思路

        空节点-插入节点，回溯接入新结点：
        # 利用后序遍历（左右根），找到第一个空节点即为要插入节点的地方；利用回溯时会返回至其“根”节点，此时将新节点接入
        # 递归出口：遇到空节点时，创建新结点
        # 左：利用回溯，将新节点插入为左子树
        # 右：利用回溯，将新节点插入为右子树
        # 根：返回根节点

        （2）过程想法

        在不改变树的基本结构的情况下，插入新结点，是比较简单的；利用回溯时将新节点接入原树中，可节省用于标识上一根节点的指针。

        2.4 代码

class Solution:
    def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
        # 在后序遍历过程中“删除”目标节点，并利用回溯过程“接”上新节点

        # 递归出口：遇见空节点，则表明查找失败
        if not root:
            return None

        # 递归出口：找到目标节点，进行删除操作，并返回新根节点
        if root.val == key:
            # 目标节点：叶子节点-->返回空
            if not root.left and not root.right:
                return None
            # 目标节点：只有左子树--->用左边作新“根”节点(删除目标节点)
            elif root.left and not root.right:
                return root.left
            # 目标节点：只有右子树--->用右边作新“根”节点(删除目标节点)
            elif root.right and not root.left:
                return root.right
            # 目标节点：既有左子树也有右子树--->用右边作新“根”节点(删除目标节点)    
            else:
                # 找到右子树最左侧的节点 cur 
                cur = root.right
                while cur.left:
                    cur = cur.left
                # 将左子树接在 cur 的左子树处，最终返回右子树(删除目标节点)
                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

三、删除二叉搜索树中的节点

        3.1 题目

        给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

一般来说，删除节点可分为两个步骤：

1. 首先找到需要删除的节点；
2. 如果找到了，删除它。

示例 1:

输入：root = [5,3,6,2,4,null,7], key = 3
输出：[5,4,6,2,null,null,7]
解释：给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。
一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。
另一个正确答案是 [5,2,6,null,4,null,7]。

示例 2:

输入: root = [5,3,6,2,4,null,7], key = 0
输出: [5,3,6,2,4,null,7]
解释: 二叉树不包含值为 0 的节点

示例 3:

输入: root = [], key = 0
输出: []

提示:

• 节点数的范围 [0, 10^4].
• -10^5 <= Node.val <= 10^5
• 节点值唯一
• root 是合法的二叉搜索树
• -10^5 <= key <= 10^5

进阶： 要求算法时间复杂度为 O(h)，h 为树的高度。

        3.2 题目链接

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

        3.3 解题思路和过程想法

        （1）解题思路

        后序遍历删节点，利用回溯接节点：在后序遍历过程中“删除”目标节点，并利用回溯过程“接”上新节点。
        # 递归出口：遇见空节点，则表明查找失败；找到目标节点，进行删除操作，并返回新根节点
        # 处理细节：
                目标节点：叶子节点-->返回空(删除目标节点)
                目标节点：只有左子树--->用左边作新“根”节点(删除目标节点)
                目标节点：只有右子树--->用右边作新“根”节点(删除目标节点)
                目标节点：既有左子树也有右子树--->用右边作新“根”节点——找到右子树最左侧的节点 cur，将左子树接在 cur 的左子树处，最终返回右子树(删除目标节点)

        （2）过程想法

        总体的处理思路比较好想，但需特别注意 “既有左子树也有右子树” 这种情况——需将当前节点的左子树接到其右子树最左节点的左指针处，或将当前节点的右子树接到其左子树的最右节点的右指针处（可简单理解为：两支合一支）。

        3.4 代码

class Solution:
    def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
        # 在后序遍历过程中“删除”目标节点，并利用回溯过程“接”上新节点

        # 递归出口：遇见空节点，则表明查找失败
        if not root:
            return None

        # 递归出口：找到目标节点，进行删除操作，并返回新根节点
        if root.val == key:
            # 目标节点：叶子节点-->返回空
            if not root.left and not root.right:
                return None
            # 目标节点：只有左子树--->用左边作新“根”节点(删除目标节点)
            elif root.left and not root.right:
                return root.left
            # 目标节点：只有右子树--->用右边作新“根”节点(删除目标节点)
            elif root.right and not root.left:
                return root.right
            # 目标节点：既有左子树也有右子树--->用右边作新“根”节点(删除目标节点)    
            else:
                # 找到右子树最左侧的节点 cur 
                cur = root.right
                while cur.left:
                    cur = cur.left
                # 将左子树接在 cur 的左子树处，最终返回右子树(删除目标节点)
                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