Python 二叉树的创建，添加结点，广度优先搜索&深度优先搜索

在python中没有类似C语言的结构体，但是可以和C++以及Java一样用类来实现二叉树结点的结构，
二叉树的结点结构代码如下：

class Node:
    def __init__(self,value):
        self.value=value
        self.left=None
        self.right=None

二叉树的深度优先搜索&广度优先搜索代码如下：
（此处注意：深度优先搜索根据访问结点的先后顺序分为“前序遍历”，“中序遍历”，“后序遍历”）

class BinaryTree:
    def __init__(self,node=None):
        self.root=node

    def add(self,value):
        if self.root is None:
            self.root=Node(value)
        else:
            queue=[]
            queue.append(self.root)

            while len(queue)>0:
                node=queue.pop(0)
                if node.left is None:
                    node.left=Node(value)
                    return
                else:
                    queue.append(node.left)
                if node.right is None:
                    node.right=Node(value)
                    return
                else:
                    queue.append(node.right)

    def breadth_travel(self):
        """广度优先遍历"""
        if self.root is None:
            return
        queue = []
        queue.append(self.root)
        while len(queue) > 0:
            node = queue.pop(0)
            print(node.value, end=" ")
            if node.left is not None:
                queue.append(node.left)
            if node.right is not None:
                queue.append(node.right)

    def preorder(self,root):
        """先序遍历"""
        if root is not None:
            print(root.value, end=" ")
            self.preorder(root.left)
            self.preorder(root.right)

    def inorder(self,root):
        """中序遍历"""
        if root is not None:
            self.inorder(root.left)
            print(root.value, end=" ")
            self.inorder(root.right)

    def postorder(self,root):
        """后序遍历"""
        if root is not None:
            self.postorder(root.left)
            self.postorder(root.right)
            print(root.value, end=" ")

测试代码：

tree = BinaryTree()
for i in range(0,10):
    tree.add(i)
tree.breadth_travel()
print()
tree.preorder(tree.root)
print()
tree.inorder(tree.root)
print()
tree.postorder(tree.root)

输出：

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 

如果要用非递归的方法实现深度优先搜索，那么这篇博客会是一个不错的参考：https://www.cnblogs.com/icekx/p/9127569.html