题目20：二叉搜索树

题目描述

给定一棵二叉搜索树，你需要实现该二叉搜索树的以下函数：

1. find(x)：如果树中存在值为x的节点，则返回true，否则返回false。
2. insert(x)：如果树中不存在值为x的节点，则插入值为x的节点，并返回true，否则返回false。
3. remove(x)：如果树中存在值为x的节点，则删除该节点，并返回true，否则返回false。

解题思路

对于一棵二叉搜索树，其满足左子树所有节点的值小于根节点的值，右子树所有节点的值大于根节点的值。可以根据二叉搜索树的这个特性，实现3个函数。

1. find(x)：从根开始，判断当前节点值是否等于x，如果等于则返回true，否则根据二叉搜索树的性质，在左子树或右子树中递归查找。

2. insert(x)：从根开始，判断当前节点值是否等于x，如果等于说明已经存在该节点，直接返回false，否则根据节点值与x的大小关系，在左子树或右子树中递归查找，直到找到一个空节点，将x插入，并返回true。

3. remove(x)：需要找到节点的位置，然后根据其左子树和右子树的情况，删除该节点后重新整理二叉搜索树的结构。这里分为3种情况：

• 被删除节点没有左子树，直接将右子树替代该节点。
• 被删除节点没有右子树，直接将左子树替代该节点。
• 被删除节点有左子树和右子树，需要将其左子树最大值或右子树最小值替代该节点。

代码实现

class TreeNode:
    def __init__(self,x):
        self.val = x
        self.left = None
        self.right = None

class BST:
    def __init__(self):
        self.root = None

    # 查找节点
    def find(self, x):
        if not self.root:
            return False
        return self._find(x,self.root)

    # 递归查找节点
    def _find(self,x,node):
        if not node:
            return False
        if node.val == x:
            return True
        elif node.val > x:
            return self._find(x,node.left)
        else:
            return self._find(x,node.right)

    # 插入节点
    def insert(self,x):
        if not self.root:
            self.root = TreeNode(x)
            return True
        else:
            return self._insert(x,self.root)

    # 递归插入节点
    def _insert(self,x,node):
        if node.val == x:
            return False
        elif node.val > x:
            if not node.left:
                node.left = TreeNode(x)
                return True
            else:
                return self._insert(x,node.left)
        else:
            if not node.right:
                node.right = TreeNode(x)
                return True
            else:
                return self._insert(x,node.right)

    # 删除节点
    def remove(self, x):
        if not self.root:
            return False
        else:
            return self._remove(x, self.root)

    # 递归删除节点
    def _remove(self, x, node):
        if not node:
            return False
        if node.val == x:
            if not node.left and not node.right:
                node = None
                return True
            elif not node.left:
                node = node.right
                return True
            elif not node.right:
                node = node.left
                return True
            else:
                pre = node.left
                while pre.right:
                    pre = pre.right
                node.val = pre.val
                node.left = self._remove(pre.val, node.left)
                return True
        elif node.val > x:
            node.left = self._remove(x, node.left)
        else:
            node.right = self._remove(x, node.right)
        return False

以上就是二叉搜索树的实现，可以对其进行单元测试来测试其正确性。