学习 二叉树

采用递归调用构建二叉树、打印、删除、计算层级

class Node():
    def __init__(self,data=None):
        self.data = data
        self.left = None
        self.right = None
    def insert(self,data):
        if self.data:
            if data<self.data:
                if self.left:
                    self.left.insert(data)
                else:
                    self.left = Node(data)
            else:
                if self.right:
                    self.right.insert(data)
                else:
                    self.right = Node(data)
        else:
            self.data = data
    # LDR
    def inorder(self):
        if self.left:
            self.left.inorder()
        print(self.data)
        if self.right:
            self.right.inorder()
    # DLR
    def preoder(self):
        print(self.data)
        if self.left:
            self.left.preoder()
        if self.right:
            self.right.preoder()
    # LRD
    def postoder(self):
        if self.left:
            self.left.preoder()
        if self.right:
            self.right.preoder()
        print(self.data)
    def search(self,val):
        if val < self.data:
            if not self.left:
                return str(val) + "不存在"
            return self.left.search(val)
        elif val > self.data:
            if not self.right:
                return str(val) + "不存在"
            return self.right.search(val)
        else:
            return str(val) + "找到了"   
class Delete_Node():
    def deleteNode(self,root,key):
        if root is None:
            return None
        if key < root.data:
            root.left = self.deleteNode(root.left,key)
            return root
        if key > root.data:
            root.right = self.deleteNode(root.right,key)
            return root
        if root.left is None:
            new_root = root.right
            return new_root
        if root.right is None:
            new_root = root.left
            return new_root
        succ = self.nax_node(root.left)
        tmp = Node(succ.data)
        tmp.left = self.left_node(root.left)
        tmp.right = root.right
        return tmp
    def left_node(self,node):
        if node.right is None:
            new_root = node.left
            return new_root
        node.right = self.left_node(node.right)
        return node
    def max_node(self,node):
        while node.right:
            node = node.right
        return node    
tree = Node()
datas = [10,21,5,9,13,28]
for d in datas:
    tree.insert(d)
tree.inorder()
del_data = 5
delete_obj = Delete_Node()
result = delete_obj.deleteNode(tree,del_data)
result.inorder()

代码来自《算法零基础一本通》

二叉树的效率

	array (sorted)	binary tree
search	O( log n )	O( log n )
insert	O( n )	O( log n )
delete	O( n )	O( log n )

---

学海无涯