Data structure and algorithm Python implements binary search tree

The characteristics of the binary tree, the left child is larger than the father, and the right node is smaller than the father

#二叉树的表示
#节点
class BSTNode(object):
    def __init__(self,key, value,right = None,left = None):
        self.key, self.value,self.right,self.left = key, value , right , left

class BinTree(object):
    def __init__(self,root = None):
        self.root = root

    @classmethod
    def build_from(cls,node_list):
        """
        通过节点信息构造二叉树
        第一次遍历我们的构造 node 节点
        第二次遍历给root 和 孩子值
        最后我们用root 初始化这个类并返回一个对象
        """
        #创建一个空字典
        node_dict = {}
        #遍历list
        for node_data in node_list:
            data = node_data['data']
            #实例化节点，赋值给字典
            node_dict[data] = BSTNode(data)
        #第二层次遍历list
        for node_data in node_list:
            data = node_data['data']
            node = node_dict[data]
            if node_data['is_root']:
                root = node
            node.left = node_dict.get(node_data['left'])
            node.right = node_dict.get(node_data['right'])
        #返回BinTree对象
        return cls(root)
        #辅助函数
    def _bst_search(self,subtree,key):
        #没有找到
        if subtree is None:
            return None
        #小于当前节点的key，就返回左子树
        elif key < subtree.key:
            return self._bst_search(subtree.left, key)
        #大于当前节点的key，就返回右子树
        elif key > subtree.key:
            return self._bst_search(subtree.right, key)
        #否则直接返回节点
        else:
            return subtree
    #取值
    def get(self,key,default = None):
        #实例化_bst_search函数，传入根节点传入key
        node = self._bst_search(self.root, key)
        #没有查到返回None
        if node is None:
            return default
        #否则返回他的value
        else:
            return node.value
    #in操作符判断
    def __contains__(self, key):
         #找到
        return self._bst_search(self.root, key) is not None
    #查找最小节点
    def _bst_min_node(self,subtree):
        if subtree is None:
            return None
        #左节点为空就返回节点
        elif subtree.left is None:
            return subtree
        #否则循环遍历
        else:
            return self._bst_min_node(subtree.left)
    #添加操作
    def bst_insert(self, subtree, key, value):
        #root是否空
        if subtree is None:
            #直接赋值
             subtree = BSTNode(key, value)
        #当key小于入口的key，给左孩子赋值
        elif key < subtree.key:
             subtree.left = self._bst_search(subtree, key, value)
        #当key大于入口的key，给右孩子赋值
        elif key > subtree.key:
            subtree.right = self._bst_search(subtree, key, value)
        #返回节点
        return  subtree
    #添加节点
    def add(self, key, value):

        node = self._bst_search(self.root , key)
        #不是空列表，就赋值返回
        if node is not None:
            node.value = value
            return False
        #是空的二叉树，就把这个节点赋值给入口
        else:
            self.root = self._bst_search(self.root, key , value)
            self.size += 1
            return True
    #删除操作—辅助方法
    def _bst_remove(self, subtree, key):
        #判断是否是个空树
        if subtree is None:
            return None
        #当key小于父亲key，就就赋值给左孩子
        elif key < subtree.key:
            subtree.left = self._bst_remove(subtree.left, key)
        #当key大于父亲的key，就给右孩子赋值
        elif key > subtree.key:
            subtree.right = self._bst_search(subtree.right, key)
        #否则
        else:
            #判断两个孩子都为空 返回None
            if subtree.left is None and subtree.right is None:
                return None
            #两个孩子其中一个是None
            elif subtree.left is None or subtree.right is None:
                #左孩子不为空
                if subtree.left is not None:
                    return subtree.left
                #右孩子不为空
                else:
                    return subtree.right
            #两个都不为空
            else:
                #取到右孩子的最小值
                successor_node = self._bst_min_node(subtree.right)
                #赋值给要删除的节点
                subtree.key, subtree.value = successor_node.key, successor_node.value
                #删除右节点的孩子，最小孩子
                subtree.right = self._bst_remove(subtree.right, successor_node.key)
                #返回被操作的节点
                return subtree
    def remove(self, key):
        assert key in self
        self.size -= 1
        return  self._bst_remove(self.root, key)