【二叉搜索树-删除】

import random


class BiTreeNode:
    def __init__(self,data):
        self.data = data
        self.lchild = None
        self.rchild = None
        self.parent = None

class BST:

    def __init__(self,li=None):
        self.root = None      #初始化根节点
        if li:                #
            for val in li: #把列表中的值都排序一下
                self.not_digui_insert(val)


    def insert(self,node,val):    #递归
        if not node:
            node = BiTreeNode(val)
        elif val <node.data:
            self.insert(node.lchild,val)
            node.lchild.parent = node
        elif val>node.data:
            self.insert(node.rchild,val)
            node.lchild.parent = node
        return node


    def not_digui_insert(self,val):         #把列表中的元素按照二叉树的方式排列一下
        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:
                return
    def look_out(self,node,val):
        if not node:
            return None
        if node.data<val:
            return self.look_out(node.rchild,val)
        elif node.data>val:
            return self.look_out(node.lchild,val)
        else:
            return node

    def no_digui_look_out(self,val):
        p = self.root
        while p:
            if p.data<val:
                p = p.rchild
            elif p.data>val:
                p = p.rchild
            else:
                return p
        else:
            return None

    def pre_ord(self,root):
        if root:
            print(root.data,end=',')
            self.pre_ord(root.lchild)
            self.pre_ord(root.rchild)

    def in_ord(self,root):
        if root:

            self.in_ord(root.lchild)
            print(root.data, end=',')
            self.in_ord(root.rchild)

    def post_ord(self,root):
        if root:
            self.post_ord(root.lchild)
            self.post_ord(root.rchild)
            print(root.data, end=',')


    def __remove_node_1(self,node):
        #情况1：node是叶子节点
        if not node.parent:  #没有父亲，自己是节点
            self.root =None
        if node == node.parent.lchild:  #父亲的左孩子
            node.parent.lchild =None
            node.parent = None    #
        else:
            node.parent.rchild = None


    def __remove_node_21(self,node):
        #情况2只有一个左孩子
        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

    def __remove_node_22(self,node):
        #情况2.2 node只有一个右孩子
        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):
        if self.root:  #不是空树
            node = self.no_digui_look_out(val)
            if not node:
                return False
            if not node.lchild and not node.rchild:
                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:   #两个孩子都有
                min_node= node.rchild   #假设右边最小
                while min_node.lchild:  #一直查找右节点的左子树中最小的节点
                    min_node = min_node.lchild   #找到右子树里最小的节点
                node.data = min_node.data  #替换当前节点的值
                #删除min_node
                if min_node.rchild:  #如果最小的节点有右子树，
                    self.__remove_node_22(min_node)
                else:
                    self.__remove_node_1(min_node)

tree = BST([1,4,5,3,6,9,10,7])

tree.in_ord(tree.root)
tree.delete(4)
print()
tree.in_ord(tree.root)