python实现二叉搜索树

class Node(object):
    def __init__(self,data=None):
        self._left=None #左节点
        self._right=None #右节点
        self._data=data
    #一系列get set方法
    def set_left(self,node):
        self._left=node
    def set_right(self,node):
        self._right=node
    def get_left(self):
        return self._left
    def get_right(self):
        return self._right
    def set_data(self,data):
        self._data=data
    def get_data(self):
        return self._data

class Binary_tree(object):
    def __init__(self,root):#这个根要是Node的对象
        self.__in_order=[]#中序遍历的列表
        self.__pre_order=[]#前序遍历的列表
        self.__post_order=[]#后序遍历的列表
        self.__root=root
    #下面带有help的都是私有函数
    def __preorder_help(self,root):#利用递归进行前序遍历
        if root:
            self.__pre_order.append(root.get_data())
            self.__preorder_help(root.get_left())
            self.__preorder_help(root.get_right())
        return self.__pre_order
    def __inorder_help(self,root):#利用递归进行中序遍历
        if root:
            self.__inorder_help(root.get_left())
            self.__in_order.append(root.get_data())
            self.__inorder_help(root.get_right())
        return self.__in_order
    def __postorder_help(self,root):#利用递归进行后序遍历
        if root:
            self.__postorder_help(root.get_left())
            self.__postorder_help(root.get_right())
            self.__post_order.append(root.get_data)
        return self.__post_order
    def preorder(self):
        return self.__preorder_help(self.__root)
    def inorder(self):
        return self.__inorder_help(self.__root)
    def postorder(self):
        return self.__postorder_help(self.__root)
#貌似纯二叉树没什么卵用，就不写示列了。
#二叉搜索树就不一样了，下面会有示列。

class BSTNode(Node):
    def __init__(self,data=None):
        Node.__init__(self,data=data)#这继承不像c++,不会默认调用父类的构造函数，需要像这样写
        self.__in_order=[]#中序遍历的列表
        self.__pre_order=[]#前序遍历的列表
        self.__post_order=[]#后序遍历的列表
    def insert(self,data):
        if data<self._data:#比此数据小就插左边，否则就插右边
            if self._left:
                return self._left.insert(data)
            else:
                self._left=BSTNode(data)
        else:
            if self._right:
                return self._right.insert(data)
            else:
                self._right=BSTNode(data)
    @staticmethod#静态方法
    def min_val_bst_node(bst_node):
        current=bst_node
        while current._left is not None:
            current=current._left
        return current
    def delete(self,data):
        if self is None:#发现没有这个数据时做以下处理
            return None
        if data<self._data:#要删的数据比此数据小，就从左子树删起
            self._left=self._left.delete(data)
        elif data>self.get_data():#要删的数据比此数据大，从右子树删起
            self._right=self._right.delete(data)
        else:#要删的就是此数据
            if self._left is None:#当左子树为空时，返回右子树，那么这个数据就删掉了，返回上层的时候，它的父节点与右子树相连
                temp=self._right
                return temp
            elif self._right is None:#当右子树为空，与上面相似
                temp=self._left
                return temp
        #如果左右子树都不为空时，把右子树的最左节点（最小结点）和此结点的数据替换
        temp = self.min_val_bst_node(self._right)
        self._data=temp._data
        self._right=self._right.delete(temp._data)
        return self
    def find(self,data):
        if data==self.get_data():
            return True
        elif data<self.get_data():#小就往左子树找，大就往右子树找
            if self._left:
                return self._left.find(data)
            else:
                return False
        else:
            if self.get_right():
                return self._right.find(data)
            else:
                return False
    #下面这些函数与纯二叉树的类似
    def inorder(self,root):
        if root:
            self.inorder(root._left)
            self.__in_order.append(root._data)
            self.inorder(root._right)
        return self.__in_order

    def preorder(self,root):
        if root:
            self.__pre_order.append(root._data)
            self.preorder(root._left)
            self.preorder(root._right)
        return self.__pre_order
    def postorder(self,root):
        if root:
            self.postorder(root._left)
            self.postorder(root._right)
            self.__post_order.append(root._data)
        return self.__post_order

class BST(object):
    def __init__(self):
        self.__root=None
    def insert(self,data):
        if self.__root:
            self.__root.insert(data)
        else:
            self.__root = BSTNode(data)

    def delete(self,data):
        if self.__root:
            return self.__root.delete(data)

    def find(self,data):
        if self.__root:
            return self.__root.find(data)
        else:
            return False

    def preorder(self):
        if self.__root:
            return self.__root.preorder(self.__root)
    def inorder(self):
        if self.__root:
            return self.__root.inorder(self.__root)

    def postorder(self):
        if self.__root:
            return self.__root.postorder(self.__root)

    def __numbers_of_nodes_help(self,root):
        if root:
            return self.__numbers_of_nodes_help(root._left)+self.__numbers_of_nodes_help(root._right)+1
        else:
            return 0
    def numbers_of_nodes(self):
        return self.__numbers_of_nodes_help(self.__root)

my_list=[8,5,10,2,6,9,11]
bst=BST()
for e in my_list:
    bst.insert(e)
print("中序遍历：",bst.inorder())
print("后序遍历：",bst.postorder())
print("前序遍历：",bst.preorder())
print("结点数：",bst.numbers_of_nodes())
#剩下的功能可以自己尝试

输出：

中序遍历： [2, 5, 6, 8, 9, 10, 11]
后序遍历： [2, 6, 5, 9, 11, 10, 8]
前序遍历： [8, 5, 2, 6, 10, 9, 11]
结点数： 7

对了，那个二叉搜索树的图是这样的：