python二叉树

python二叉树

• 树的添加

  class Node(object):
      """结点"""
      def __init__(self, item):
          self.elem = item
          self.lchild = None
          self.rchild = None
  
  
  class Tree(object):
      """二叉树"""
  
      def __init__(self):
          self.root = None
  
  
      def add(self, item):
          """添加元素"""
          # 创建结点
          node = Node(item)
          
          # 判断首结点是否为空
          if self.root is None:
              self.root = node # 为空时 直接把这个结点添加到首元素
              return
  
          # 把首结点这个加入到队列中
          queue = [self.root]
  
          # 列表为空时 退出循环
          while queue:
  
              cur_node = queue.pop(0) # 弹出列表的第一个元素
              if cur_node.lchild is None: # 结点左边为空时
                  cur_node.lchild = node  # 把这个元素添加到左边
                  return                  
              else:
                  queue.append(cur_node.lchild) # 不为空时把这个结点添加到列表中
  
              if cur_node.rchild is None:  # 同上 这边是右边的
                  cur_node.rchild = node
                  return
              else:
                  queue.append(cur_node.rchild)
  
          
      def breadth_travel(self):
          """广度遍历(横向遍历)"""
          if self.root is None:
              return
  
          queue = [self.root]
  
          while queue:
              cur_node = queue.pop(0)
              print(cur_node.elem, end=" ") # 打印结点的值
              if cur_node.lchild is not None: # 结点左边不为None的时候 
                  queue.append(cur_node.lchild) # 把这个结点添加到 列表中
              if cur_node.rchild is not None: # 同上 是右边而已
                  queue.append(cur_node.rchild)
  
  
      def preorder(self, node):
          """先序遍历 根节点->左子数->右子数"""
          # 用递归
          if node is None:
              return
  
          print(node.elem, end=" ")
          self.preorder(node.lchild)
          self.preorder(node.rchild)
  
  
  
      def inorder(self, node):
          """中序遍历 左子数->根节点->又子数"""
          # 用递归
          if node is None:
              return
  
          self.inorder(node.lchild)
          print(node.elem, end=" ")
          self.inorder(node.rchild)
  
  
      def postorder(self, node):
          """后序遍历 左子数->右子数->根节点"""
          # 用递归
          if node is None:
              return
  
          self.postorder(node.lchild)
          self.postorder(node.rchild)
          print(node.elem, end=" ")
  
  
  
  # 广度遍历 0 1 2 3 4 5 6 7 8 9
  # 先序遍历 0 1 3 7 8 4 9 2 5 6 
  # 中序遍历 7 3 8 1 9 4 0 5 2 6 
  # 后序遍历 7 8 3 9 4 1 5 6 2 0
  
  if __name__ == "__main__":
      tree = Tree()
      tree.add(0)
      tree.add(1)
      tree.add(2)
      tree.add(3)
      tree.add(4)
      tree.add(5)
      tree.add(6)
      tree.add(7)
      tree.add(8)
      tree.add(9)
      tree.breadth_travel()
      print("")
      tree.preorder(tree.root) # self.root根节点
      print("")
      tree.inorder(tree.root)
      print("")
      tree.postorder(tree.root)
      print("")
      
  # 运行结果
  0 1 2 3 4 5 6 7 8 9 
  0 1 3 7 8 4 9 2 5 6 
  7 3 8 1 9 4 0 5 2 6 
  7 8 3 9 4 1 5 6 2 0