python traversal

以下是Python中二叉树的遍历方法的示例代码：

# 定义二叉树节点类
class TreeNode:
    def __init__(self, data):
        self.data = data
        self.left_child = None
        self.right_child = None

# 定义二叉树类
class BinaryTree:
    def __init__(self):
        self.root = None

    # 插入节点
    def insert(self, data):
        new_node = TreeNode(data)
        if self.root is None:
            self.root = new_node
        else:
            current = self.root
            while True:
                if data < current.data:
                    if current.left_child is None:
                        current.left_child = new_node
                        return
                    else:
                        current = current.left_child
                else:
                    if current.right_child is None:
                        current.right_child = new_node
                        return
                    else:
                        current = current.right_child

    # 层次遍历
    def level_order_traversal(self, start):
        if start is None:
            return
        queue = []
        queue.append(start)
        while len(queue) > 0:
            print(queue[0].data, end=' ')
            node = queue.pop(0)
            if node.left_child is not None:
                queue.append(node.left_child)
            if node.right_child is not None:
                queue.append(node.right_child)

    # 先序遍历
    def preorder_traversal(self, start):
        if start is None:
            return
        print(start.data, end=' ')
        self.preorder_traversal(start.left_child)
        self.preorder_traversal(start.right_child)

    # 中序遍历
    def inorder_traversal(self, start):
        if start is None:
            return
        self.inorder_traversal(start.left_child)
        print(start.data, end=' ')
        self.inorder_traversal(start.right_child)

    # 后序遍历
    def postorder_traversal(self, start):
        if start is None:
            return
        self.postorder_traversal(start.left_child)
        self.postorder_traversal(start.right_child)
        print(start.data, end=' ')

以上代码中，`BinaryTree`类定义了二叉树的节点和插入节点的方法，以及四种遍历方法：层次遍历、先序遍历、中序遍历和后序遍历。其中，层次遍历使用了队列，而其他三种遍历方法使用了递归。

以下是使用示例：

# 创建二叉树
tree = BinaryTree()
tree.insert(5)
tree.insert(3)
tree.insert(7)
tree.insert(1)
tree.insert(4)
tree.insert(6)
tree.insert(8)

# 层次遍历
print('层次遍历：', end=' ')
tree.level_order_traversal(tree.root)
print()

# 先序遍历
print('先序遍历：', end=' ')
tree.preorder_traversal(tree.root)
print()

# 中序遍历
print('中序遍历：', end=' ')
tree.inorder_traversal(tree.root)
print()

# 后序遍历
print('后序遍历：', end=' ')
tree.postorder_traversal(tree.root)
print()

输出结果为：

层次遍历： 5 3 7 1 4 6 8 
先序遍历： 5 3 1 4 7 6 8 
中序遍历： 1 3 4 5 6 7 8 
后序遍历： 1 4 3 6 8 7 5