1 二叉搜索树
1.1 二叉搜索树-插入
1.2 二叉搜索树-查询
1.3 二叉搜索树-删除

1 二叉搜索树

二叉搜索树是一颗二叉树且满足性质:设是二叉树的一个节点。
如果y是x左子树的一个节点，那么y.key< x.key;如果y是x右子树的一个节点，那么y.key > x.key。

二叉搜索树的操作:查询、插入、删除

1.1 二叉搜索树-插入

class BiTreeNode:
    def __init__(self, data):
        """
        初始化二叉树节点
        :param data: 节点的值
        """
        self.data = data  # 节点的值
        self.lchild = None  # 左子节点
        self.rchild = None  # 右子节点
        self.parent = None  # 父节点


class BST:
    def __init__(self, li: list):
        """
        初始化二叉搜索树，并插入给定的值
        :param li: 包含插入值的列表
        """
        self.root = None  # 初始化根节点为空
        if li:
            for val in li:
                self.insert_no_rec(val)  # 使用非递归插入方法将列表中的值插入树中

    def insert(self, node, val):
        """
        递归插入节点到二叉搜索树中
        :param node: 当前节点
        :param val: 要插入的值
        :return: 插入后的节点
        """
        if not node:
            # 如果当前节点为空，则创建一个新节点作为叶节点
            return BiTreeNode(val)
        elif val < node.data:
            # 如果要插入的值小于当前节点的值，则递归插入到左子树
            node.lchild = self.insert(node.lchild, val)
            node.lchild.parent = node  # 更新左子节点的父节点
        elif val > node.data:
            # 如果要插入的值大于当前节点的值，则递归插入到右子树
            node.rchild = self.insert(node.rchild, val)
            node.rchild.parent = node  # 更新右子节点的父节点
        # 如果要插入的值等于当前节点的值，则不做任何操作（BST中不允许重复值）
        return node

    def insert_no_rec(self, val):
        """
        非递归插入节点到二叉搜索树中
        :param val: 要插入的值
        :return: None
        """
        p = self.root
        if not p:
            # 如果树为空，将新节点设置为根节点
            self.root = BiTreeNode(val)
            return
        while True:
            if val < p.data:
                # 如果要插入的值小于当前节点的值，则移动到左子树
                if p.lchild:
                    p = p.lchild
                else:
                    # 如果左子树为空，则在此位置插入新节点
                    p.lchild = BiTreeNode(val)
                    p.lchild.parent = p  # 更新新节点的父节点
                    return
            elif val > p.data:
                # 如果要插入的值大于当前节点的值，则移动到右子树
                if p.rchild:
                    p = p.rchild
                else:
                    # 如果右子树为空，则在此位置插入新节点
                    p.rchild = BiTreeNode(val)
                    p.rchild.parent = p  # 更新新节点的父节点
                    return
            else:
                # 如果要插入的值等于当前节点的值，则不做任何操作（BST中不允许重复值）
                return

    def pre_order(self, root):
        """
        二叉树的前序遍历
        :param root:
        :return:
        """
        if root:
            print(root.data, end=',')
            self.pre_order(root.lchild)
            self.pre_order(root.rchild)

    def mid_order(self, root):
        """
        二叉树的中序遍历
        :param root:
        :return:
        """
        if root:
            self.mid_order(root.lchild)
            print(root.data, end=',')
            self.mid_order(root.rchild)

    def post_order(self, root):
        """
        二叉树的后序遍历
        :param root:
        :return:
        """
        if root:
            self.post_order(root.lchild)
            self.post_order(root.rchild)
            print(root.data, end=',')


tree = BST([4, 5, 6, 7, 1, 3, 2, 8])
tree.post_order(tree.root)  # 2,3,1,8,7,6,5,4,
print('')
tree.mid_order(tree.root)  # 1,2,3,4,5,6,7,8,
print('')
tree.post_order(tree.root)  # 2,3,1,8,7,6,5,4,

1.2 二叉搜索树-查询

class BST:
	
    def query(self, node, val):
        """
        递归查询二叉搜索树中的节点
        :param node: 当前节点
        :param val: 要查询的值
        :return: 节点对象（如果找到）或 None（如果未找到）
        """
        if not node:
            # 如果当前节点为空，则值未找到，返回 None
            return None
        if node.data < val:
            # 如果当前节点的值小于要查询的值，则递归查询右子树
            return self.query(node.rchild, val)
        elif node.data > val:
            # 如果当前节点的值大于要查询的值，则递归查询左子树
            return self.query(node.lchild, val)
        else:
            # 如果当前节点的值等于要查询的值，返回当前节点
            return node

    def query_no_rec(self, val):
        """
        非递归查询二叉搜索树中的节点
        :param val: 要查询的值
        :return: 节点对象（如果找到）或 None（如果未找到）
        """
        p = self.root
        while p:
            if p.data < val:
                # 如果当前节点的值小于要查询的值，则移动到右子树
                p = p.rchild
            elif p.data > val:
                # 如果当前节点的值大于要查询的值，则移动到左子树
                p = p.lchild
            else:
                # 如果当前节点的值等于要查询的值，返回当前节点
                return p
        # 如果遍历结束仍未找到值，返回 None
        return None

1.3 二叉搜索树-删除

class BST:
    # 其他方法...

    def __remove_node_1(self, node):
        """
        情况1：node是叶子节点
        :param node: 要删除的节点
        :return: None
        """
        if not node.parent:
            # 如果节点没有父节点，说明它是根节点，直接将根节点置为 None
            self.root = None
        elif node == node.parent.lchild:
            # 如果节点是它父节点的左孩子，则将父节点的左孩子指针置为 None
            node.parent.lchild = None
        else:
            # 如果节点是它父节点的右孩子，则将父节点的右孩子指针置为 None
            node.parent.rchild = None
        node.parent = None  # 清除删除节点的父节点引用

    def __remove_node_21(self, node):
        """
        情况2.1：node只有一个左孩子
        :param node: 要删除的节点
        :return: None
        """
        if not node.parent:
            # 如果节点没有父节点，说明它是根节点，将根节点指向它的左孩子
            self.root = node.lchild
            node.lchild.parent = None
        elif node == node.parent.lchild:
            # 如果节点是它父节点的左孩子，则将父节点的左孩子指向该节点的左孩子
            node.parent.lchild = node.lchild
            node.lchild.parent = node.parent
        else:
            # 如果节点是它父节点的右孩子，则将父节点的右孩子指向该节点的左孩子
            node.parent.rchild = node.lchild
            node.lchild.parent = node.parent

    def __remove_node_22(self, node):
        """
        情况2.2：node只有一个右孩子
        :param node: 要删除的节点
        :return: None
        """
        if not node.parent:
            # 如果节点没有父节点，说明它是根节点，将根节点指向它的右孩子
            self.root = node.rchild
        elif node == node.parent.lchild:
            # 如果节点是它父节点的左孩子，则将父节点的左孩子指向该节点的右孩子
            node.parent.lchild = node.rchild
            node.rchild.parent = node.parent
        else:
            # 如果节点是它父节点的右孩子，则将父节点的右孩子指向该节点的右孩子
            node.parent.rchild = node.rchild
            node.rchild.parent = node.parent

    def delete(self, val):
        """
        删除二叉搜索树中的节点
        :param val: 要删除的节点的值
        :return: 如果删除成功返回 True，否则返回 False
        """
        if self.root:  # 如果树非空
            node = self.query_no_rec(val)  # 查找要删除的节点
            if not node:
                return False  # 如果节点不存在，返回 False
            if not node.lchild and not node.rchild:
                # 情况1：叶子节点
                self.__remove_node_1(node)
            elif not node.rchild:
                # 情况2.1：只有左孩子
                self.__remove_node_21(node)
            elif not node.lchild:
                # 情况2.2：只有右孩子
                self.__remove_node_22(node)
            else:
                # 情况3：左右孩子都有
                # 查找右子树中最小的节点
                min_node = node.rchild
                while min_node.lchild:
                    min_node = min_node.lchild
                node.data = min_node.data  # 用最小节点的值替换当前节点的值
                # 删除最小节点
                if min_node.rchild:
                    self.__remove_node_22(min_node)
                else:
                    self.__remove_node_1(min_node)
            return True  # 删除成功
        return False  # 树为空，删除失败