python deque 遍历

你可以使用 `for` 循环来遍历一个 `deque`，也可以使用 `while` 循环和 `popleft()` 方法来遍历它。

使用 `for` 循环：

from collections import deque

my_deque = deque([1, 2, 3, 4, 5])

for item in my_deque:
    print(item)

使用 `while` 循环和 `popleft()` 方法：

from collections import deque

my_deque = deque([1, 2, 3, 4, 5])

while len(my_deque) > 0:
    item = my_deque.popleft()
    print(item)

这两种方式的输出结果都是：

1
2
3
4
5

相关问题

python层序遍历二叉树

在Python中，层序遍历（也称为广度优先遍历）二叉树是一种按层次顺序访问节点的方法，从根节点开始，逐层向下遍历。这种遍历方式通常使用队列来辅助实现，因为队列的特点是先进先出（FIFO），非常适合用来处理需要按照顺序访问同一层级节点的情况。

以下是层序遍历二叉树的基本步骤：

1. 如果二叉树为空，则直接结束遍历。
2. 创建一个空的队列，并将根节点（如果存在）入队。
3. 当队列不为空时，执行以下操作：
a. 弹出队首元素（当前层的第一个节点）并访问它。
b. 将该节点的左右子节点（如果存在）分别入队，以便后续访问。
4. 重复步骤3，直到队列为空。

以下是一个简单的Python代码实现：

from collections import deque

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

def level_order_traversal(root):
    if root is None:
        return []

    queue = deque([root])  # 使用双端队列存储节点
    result = []

    while queue:
        level_nodes = []  # 用于存放当前层的节点值
        size = len(queue)

        for _ in range(size):
            node = queue.popleft()  # 弹出队首节点
            level_nodes.append(node.value)

            if node.left:  # 如果有左子节点，入队
                queue.append(node.left)
            if node.right:  # 如果有右子节点，入队
                queue.append(node.right)

        result.append(level_nodes)  # 将当前层节点值添加到结果列表

    return result

# 示例
# 假设我们有如下二叉树
#     1
#    / \
#   2   3
#  / \   \
# 4   5   6
root = Node(1, Node(2, Node(4), Node(5)), Node(3, Node(6)))

print(level_order_traversal(root))  # 输出: [, [2, 3], [4, 5, 6]]

python怎么遍历二叉树

在Python中，遍历二叉树通常有两种主要方式：前序遍历（Preorder）、中序遍历（Inorder）和后序遍历（Postorder），以及层序遍历（Level Order）。这里以递归的方式简单介绍这几种方法：

1. **前序遍历**（Preorder Traversal）：先访问根节点，然后递归地访问左子树，最后访问右子树。

def preorder_traversal(root):
    if root is not None:
        print(root.val)  # 访问当前节点
        preorder_traversal(root.left)  # 遍历左子树
        preorder_traversal(root.right)  # 遍历右子树

2. **中序遍历**（Inorder Traversal）：先递归地访问左子树，然后访问根节点，最后访问右子树。

def inorder_traversal(root):
    if root is not None:
        inorder_traversal(root.left)
        print(root.val)  # 访问当前节点
        inorder_traversal(root.right)

3. **后序遍历**（Postorder Traversal）：先递归地访问左子树和右子树，最后访问根节点。

def postorder_traversal(root):
    if root is not None:
        postorder_traversal(root.left)
        postorder_traversal(root.right)
        print(root.val)

4. **层序遍历**（Level Order Traversal，也叫广度优先搜索，BFS）：从上到下、从左到右逐层访问节点。

from collections import deque

def level_order_traversal(root):
    if root is None:
        return []
    queue = deque([root])
    result = []
    while queue:
        node = queue.popleft()
        result.append(node.val)
        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)
    return result