二分搜索树python实现（遍历的递归和非递归实现）

class BST:
    class _Node:
        def __init__(self,e):
            self.e=e
            self.left=None
            self.right=None
    def __init__(self):
        self._root=None
        self._size=0
    def size(self):
        return self._size
    def is_empty(self):
        return self._size==0
    def add(self,e):
        self._root=self._add(self._root,e)
    def _add(self,node,e):
        if not node:
            node=self._Node(e)
            self._size+=1
            return node
        if node.e==e:
            return node
        elif node.e>e:
            node.left=self._add(node.left,e)
        else:
            node.right=self._add(node.right,e)
        return node
    def contains(self,e):
        return self._contains(self._root,e)
    def _contains(Self,node,e):
        if not node:
            return False
        if node.e==e:
            return True
        if node.e>e:
            self._contains(node.left,e)
        if node.e<e:
            self._contains(node.right,e)
    def pre_order(self):
        return self._pre_order(self._root)
    def _pre_order(self,node):
        if not node:
            return
        print(node.e)
        self._pre_order(node.left)
        self._pre_order(node.right)
    def pre_order_NR(self):
        stack=[self._root]
        while stack:
            node=stack.pop()
            print(node.e)
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
    def in_order(self):
        return self._in_order(self._root):
    def _in_order(self,node):
        if not node:
            return
        self._in_order(node.left)
        print(node.e)
        self._in_order(node.right)
    def in_order_NR(self):
        stack=[] 
        node=self._root
        while stack or node:
            while node:
                stack.append(node)
                node=node.left
            cur=stack.pop() 
            print(cur.e)
            node=cur.right
    def post_order(self):
        return self._post_order(self._root)
    def _post_order(self,node):
        if not node:
            return
        self._post_order(node.left)
        self._post_order(node.right)
        print(node.e)
    def post_order_NR(self):
        stack=[]
        node=self._root
        pre=None
        while stack or node:
            while node:
                stack.append(node)
                node=node.left
            curr=stack[-1]
            if curr.right==None or pre==curr.right:
                stack.pop()
                pre=curr
                print(curr.e)
            else:
                node=curr.right
    def level_order(self):
        queue=[]
        queue.append(self._root)
        while queue:
            curr=queue.pop(0)
            print(curr.e)
            if curr.left:
                queue.append(curr.left)
            if curr.right:
                queue.append(curr.right)
    def minimum(self):
        if self.is_empty():
            raise ValueError('BST ERROR')
        self._minimum(self._root)
    def _minimum(self):
        if not node.left:
            return node
        return self._minimum(node.left)
    def maximum(self):
        if self.is_empty():
            raise ValueError('BST ERROR')
        self._maximum(self._root)
    def _maximum(self):
        if not node.right:
            return node
        return self._maximum(node.right)
    def remove_min(self):
        ret=self.minimum()
        self._root=self._remove_min(self._root)
        return ret
    def _remove_min(self,node):
        if not node.left:
            right_node=node.right
            node.right=None
            self._size-=1
            return right_node
        node.left=self._remove_min(node.left)
        return node
    def remove_max(self):
        ret=self.maximum()
        self._root=self._remove_max(self._root)
        return ret
    def _remove_max(self,node):
        if not node.rigth:
            left_node=node.left
            node.left=None
            self._size-=1
            return left_node
        node.right=self._remove_max(node.right)
        return node
    def remove(self,e):
        self._root=self._remove(self._root,e)
    def _remove(self,node,e):
        if not node:
            return
        if node.e>e:
            node.left=self._remove(node.left,e)
        elif node.e<e:
            node.right=self._remove(node.right,e)
        else:
            if not node.left:
                right_node=node.right
                node.right=None
                self._size-=1
                return right_node
            if not node.right:
                left_node=node.left
                node.left=None
                self._size-=1
                return left_node
            successor=self._minimum(node.right)
            successor.right=self._remove_min(node.right)
            successor.left=node.left
            node.left=node.right=None
            return successor