LeetCode0450: 删除二叉搜索树中的节点

题目介绍

描述：

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

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

首先找到需要删除的节点； 如果找到了，删除它。 说明： 要求算法时间复杂度为 O(h)，h 为树的高度。

示例:

root = [5,3,6,2,4,null,7]
key = 3

    5
   / \\
  3   6
 / \\   \\
2   4   7

给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。

一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。

    5
   / \\
  4   6
 /     \\
2       7

另一个正确答案是 [5,2,6,null,4,null,7]。

    5
   / \\
  2   6
   \\   \\
    4   7

解题思路：

递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果。

写树相关的算法，简单说就是，先搞清楚当前 root 节点该做什么，然后根据函数定义递归调用子节点，递归调用会让孩子节点做相同的事情。

二叉树题目的一个难点在于如何通过题目的要求思考出每一个节点需要做什么

自己的解法实现

这题有点难，自己没做出来。

网上比较优秀的解法

解法一

方法：递归 这里有三种可能的情况：

1. 要删除的节点为叶子节点，可以直接删除。
2. 要删除的结点不是叶子节点且拥有右节点，则该节点可以由该节点的后继节点进行替代，该后继节点位于右子树中较低的位置。然后可以从后继节点的位置递归向下操作以删除后继节点。
3. 要删除的节点不是叶子节点，且没有右节点但是有左节点。这意味着它的后继节点在它的上面，但是我们并不想返回。我们可以使用它的前驱节点进行替代，然后再递归的向下删除前驱节点。

算法：

如果 key > root.val，说明要删除的节点在右子树，root.right = deleteNode(root.right, key)。 如果 key < root.val，说明要删除的节点在左子树，root.left = deleteNode(root.left, key)。 如果 key == root.val，则该节点就是我们要删除的节点，则： 如果该节点是叶子节点，则直接删除它：root = null。 如果该节点不是叶子节点且有右节点，则用它的后继节点的值替代 root.val = successor.val，然后删除后继节点。 如果该节点不是叶子节点且只有左节点，则用它的前驱节点的值替代 root.val = predecessor.val，然后删除前驱节点。 返回 root。

def successor(self, root):
        """
        One step right and then always left
        """
        root = root.right
        while root.left:
            root = root.left
        return root.val

    def predecessor(self, root):
        """
        One step left and then always right
        """
        root = root.left
        while root.right:
            root = root.right
        return root.val

    def deleteNode(self, root, key):
        if not root: return None

        # delete from the right subtree
        if key > root.val:
            root.right = self.deleteNode(root.right, key)
        # delete from the left subtree
        elif key < root.val:
            root.left = self.deleteNode(root.left, key)
        # delete the current node
        else:
            # the node is a leaf
            if not (root.left or root.right):
                root = None
            # the node is not a leaf and has a right child
            elif root.right:
                root.val = self.successor(root)
                root.right = self.deleteNode(root.right, root.val)
            # the node is not a leaf, has no right child, and has a left child
            else:
                root.val = self.predecessor(root)
                root.left = self.deleteNode(root.left, root.val)

        return root

解法二

解题思路 #思路：先查找待删除结点

case0 结点不存在，empty,return root #找到后有四种情况

case1 结点没孩子,直接删除 case2 结点只有一个孩子,是左孩子,让左孩子即位 case3 结点只有一个孩子,是右孩子,让右孩子即位 case4 结点有俩孩子,用 right tree left most 替换待删除结点,然后把right tree left most那个结点删除

def deleteNode2(self, root, key):
        if not root: return None    # case 0 要删除的节点不存在
        if root.val > key:    # 要删除的结点在左子树
            root.left = self.deleteNode2(root.left, key)
        elif root.val < key:    # 要删除的结点在右子树
            root.right = self.deleteNode2(root.right, key)
        else:    # 已经找到了要删除的结点,开始进行删除操作
            # case1 没有孩子,直接删除返回空
            if not root.left and not root.right:
                root = None
                return root
            elif root.left is not None and root.right is None:    # case2 只有一个孩子,左孩子,让左孩子即位
                tmp = root.left
                root = None
                return tmp
            elif root.left is None and root.right is not None:    # case3 只有一个孩子,右孩子,让右孩子即位
                tmp = root.right
                root = None
                return tmp
            # case4 有两个孩子,和右子树 left most交换后在右子树中删除 left most
            else:
                curr = root.right
                while curr.left:    # find left most
                    curr = curr.left
                # 退出while循环时候的curr就是left most
                root.val = curr.val    #即位
                root.right = self.deleteNode2(root.right, key)    # 在右子树中删除该结点后作为新的右子树
        return root

解法三

def deleteNode3(self, root, key):
        def delete(root, key, l):
            if not root: return l
            if root.val == key:
                return delete(root.right, key, root.left)
            elif root.val < key:
                root.right = delete(root.right, key, l)
                return root
            else:
                root.left = delete(root.left, key, l)
                return root
        return delete(root, key, None)

解法四

找到右子树的最左节点 放到上面就行

相关知识总结和思考

相关知识：

BFS：广度/宽度优先。其实就是从上到下，先把每一层遍历完之后再遍历一下一层。

可以使用Queue的数据结构。我们将root节点初始化进队列，通过消耗尾部，插入头部的方式来完成BFS。

二叉搜索树（BST）的特性：

1. 若它的左子树不为空，则所有左子树上的值均小于其根节点的值
2. 若它的右子树不为空，则所有右子树上的值均大于其根节点得值
3. 它的左右子树也分别为二叉搜索树

递归与迭代的区别

递归：重复调用函数自身实现循环称为递归； 迭代：利用变量的原值推出新值称为迭代，或者说迭代是函数内某段代码实现循环；