2.13_binary_search_tree(BST)_二叉搜索树

二叉树节点类

class BiTreeNode(object):
    """二叉树节点类"""

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

 二叉搜索树 (BST)

class BST(object):

    def __init__(self, li=None):
        self.root = None
        if li:
            for val in li:
                self.insert_no_rec(val)

    def insert(self, node, val):

        if not node:
            node = 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

        return node

    def insert_no_rec(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 query(self, node, val):

        if not node:
            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):

        p = self.root
        while p:
            if p.data < val:
                p = p.rchild
            elif p.data > val:
                p = p.lchild
            else:
                return p
        return None

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

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

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

    def __remove_node_1(self, node):
        """情况1：node 是叶子节点"""

        # 判断是不是根节点
        if not node.parent:
            self.root = None

        # node 是它父亲的左孩子
        if node == node.parent.lchild:
            node.parent.lchild = None
        else:
            node.parent.rchild = None

    def __remove_node_2l(self, node):
        """情况2.1：node 只有一个左孩子"""

        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_2r(self, node):
        """情况2.2：node 只有一个右孩子"""

        if not node.parent:
            self.root = node.rchild
            node.parent = None
        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.query_no_rec(val)
            # 节点不存在
            if not node:
                return False

            # 情况1：node 是叶子节点
            if not node.lchild and not node.rchild:
                self.__remove_node_1(node)
            # 情况2.1：node 只有一个左孩子
            elif not node.rchild:
                self.__remove_node_2l(node)
            # 情况2.2：node 只有一个右孩子
            elif not node.lchild:
                self.__remove_node_2r(node)
            # 情况3：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_2r(min_node)
                else:
                    self.__remove_node_1(min_node)

测试代码： 

import random


li = list(range(0, 500, 2))
random.shuffle(li)

tree = BST(li)
tree.pre_order(tree.root)
print('')
tree.in_order(tree.root)
print('')
tree.post_order(tree.root)

print(tree.query_no_rec(4).data)


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

tree.delete(4)
tree.delete(1)
tree.delete(8)
tree.in_order(tree.root)