数据结构与算法 Python实现 二叉查找树

二叉树的特点，左孩子大于父亲，右节点小于父亲

#二叉树的表示
#节点
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)