[DnA] 二分查找树

代码：

class BiTreeNode:
    def __init__(self,val):
        self.val = val
        self.lchild = None
        self.rchild = None
        self.parent = None

class BST:
    def __init__(self,list):
        self.root = None
        if list:
            for ele in list:
                self.insert(self.root,ele)

    # node : 本次判断的根节点
    # val : 要插入的值
    # 递归函数用于无法绕开的两个问题： 1.参照物 ; 2.循环终止条件
    def insert(self,basenode:BiTreeNode,val):
        # 如果判断的节点不存在,则新创建一个节点 并返回
        if not basenode:
            basenode = BiTreeNode(val)
            if not self.root:
                self.root = BiTreeNode(val)
        # 如果判断节点存在,则对比判断节点的值和当前值
        elif val > basenode.val:                   #如果当前值比判断节点大
            basenode.rchild = self.insert(basenode.rchild,val)       #这里的递归最终会创建一个新节点
            basenode.rchild.parent = basenode
        elif val < basenode.val:                   #往左边插
            basenode.lchild = self.insert(basenode.lchild, val)
            basenode.lchild.parent = basenode
        else:                                       #相等则什么都不做,或者自定义行为,比如hash列表
            pass
        return basenode

    def insert_not_rec(self,val):
        p = self.root
        if not p:
            self.root = BiTreeNode(val)
            return
        while True:
            if val > p.val:
                if p.rchild:
                    p = p.rchild
                else:
                    p.rchild = BiTreeNode(val)
                    p.rchild.parent = p
                    return
            elif val < p.val:
                if p.lchild:
                    p = p.lchild
                else:
                    p.lchild = BiTreeNode(val)
                    p.lchild.parent = p
                    return
            else:
                return

    def query(self,basenode:BiTreeNode,val):
        if not basenode:
            return None
        elif val > basenode.val:
            tmp = self.query(basenode.rchild,val)
            return tmp
        elif val < basenode.val:
            tmp = self.query(basenode.lchild,val)
            return tmp
        elif val == basenode.val:
            return basenode

    def query_not_rec(self,val):
        p = self.root
        while True:
            if not p:
                return None
            elif val > p.val:
                p = p.rchild
            elif val < p.val:
                p = p.lchild
            else:
                return p

    #前序遍历
    def pre_order(self,basenode:BiTreeNode):
        if basenode:
            print(basenode.val)
            self.pre_order(basenode.lchild)
            self.pre_order(basenode.rchild)

if __name__ == "__main__":
    ins = BST([5,4,2,9,7,10,3,8])
    ins.pre_order(ins.root)
    #mp = ins.query(ins.root,8)
    tmp = ins.query_not_rec(8)
    if tmp:
        print(tmp.val)
    else:
        print("None")