python小记-队列

队列（Queue）是一种常见的数据结构，它遵循先进先出（First-In-First-Out，FIFO）的原则。在队列中，新元素（也称为项）总是添加到队列的末尾，而最早添加的元素总是在队列的前面，类似于排队等待的现象。

队列的主要操作包括：

1. 入队（enqueue）：将新元素添加到队列的末尾。
2. 出队（dequeue）：从队列的前面移除最早添加的元素。
3. 判空（isEmpty）：检查队列是否为空，如果队列中没有任何元素，则返回True，否则返回False。
4. 获取队首元素（front）：获取队列的前面最早添加的元素，但不移除它。

队列常用的实现方式包括：

1. 数组实现：使用数组来存储队列的元素，入队和出队的时间复杂度为O(1)。
2. 链表实现：使用链表来存储队列的元素，入队和出队的时间复杂度为O(1)。

队列在计算机科学和算法中有广泛的应用，例如：

1. 广度优先搜索（BFS）：在图的遍历和搜索中，BFS使用队列来实现按层次遍历图的节点。
2. 任务调度：在操作系统中，任务调度器使用队列来管理待执行的任务，按照优先级和先后顺序进行调度执行。
3. 线程池：在多线程编程中，线程池使用队列来存储待执行的任务，从队列中取出任务分配给空闲线程执行。

在Python中，可以使用内置的collections模块中的deque类来实现队列。deque是一个双端队列，支持高效的在两端进行元素的添加和删除操作。以下是使用deque实现队列的示例：

from collections import deque

# 创建一个空队列
queue = deque()

# 入队操作
queue.append(1)
queue.append(2)
queue.append(3)

# 出队操作
first_element = queue.popleft()
print(first_element)  # 输出: 1

# 获取队首元素
front_element = queue[0]
print(front_element)  # 输出: 2

以上代码演示了如何使用deque来实现队列的入队和出队操作，并获取队首元素。

图的BFS

当使用BFS算法解决问题时，队列起到了关键的作用。以下是一个详细的例子，演示了如何使用队列来实现BFS算法解决图的遍历问题。

假设有以下图的表示：

   1---2
  / \  |
 0---3-4

我们想要按层次遍历这个图的节点，从节点0开始。首先，我们将节点0入队列，并标记为已访问。然后，我们从队列中取出节点0，并将其所有未访问的相邻节点入队列。接着，我们继续从队列中取出节点，直到队列为空。每次取出节点后，我们将该节点标记为已访问，并将其所有未访问的相邻节点入队列。

下面是使用队列实现BFS算法的Python代码：

from collections import deque

# 定义图的邻接表表示
graph = {
    0: [1, 3],
    1: [0, 2, 3],
    2: [1, 4],
    3: [0, 1, 4],
    4: [2, 3]
}

# 使用队列实现BFS算法
def bfs(start_node):
    visited = set()  # 用一个集合来保存已访问过的节点
    queue = deque()  # 使用deque作为队列
    queue.append(start_node)
    visited.add(start_node)

    while queue:
        current_node = queue.popleft()  # 取出队列头部的节点
        print(current_node)  # 输出当前节点

        for neighbor in graph[current_node]:
            if neighbor not in visited:
                queue.append(neighbor)  # 将未访问过的相邻节点入队列
                visited.add(neighbor)  # 标记相邻节点为已访问

# 从节点0开始进行BFS遍历
bfs(0)

输出结果为：

0
1
3
2
4

这是因为我们按层次遍历图的节点，从节点0开始，先输出0的所有相邻节点，然后依次输出1、3、2和4的所有相邻节点。注意，由于图中有环，我们使用集合来记录已访问过的节点，避免重复访问。通过队列和集合的组合，我们实现了高效的BFS算法，能够广泛应用于图的遍历和搜索问题。

树的层次遍历

队列在树中的应用主要体现在树的层次遍历（也称为广度优先搜索 BFS）上。在树的层次遍历中，我们从树的根节点开始，依次按层次遍历树的所有节点。使用队列可以帮助我们实现这种层次遍历的顺序。

下面是一个使用队列实现树的层次遍历的Python代码：

from collections import deque

# 定义树的节点类
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

# 使用队列实现树的层次遍历
def level_order_traversal(root):
    if not root:
        return []

    result = []
    queue = deque()  # 使用deque作为队列
    queue.append(root)

    while queue:
        current_level = []  # 用于存储当前层次的节点值
        level_size = len(queue)

        for _ in range(level_size):
            node = queue.popleft()
            current_level.append(node.val)

            if node.left:
                queue.append(node.left)

            if node.right:
                queue.append(node.right)

        result.append(current_level)

    return result

# 创建一个示例树
#       1
#      / \
#     2   3
#    / \   \
#   4   5   6
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.right = TreeNode(6)

# 进行树的层次遍历
print(level_order_traversal(root))

输出结果为：

[[1], [2, 3], [4, 5, 6]]

在这个例子中，我们使用队列实现了树的层次遍历，按层次输出树的节点值。首先将树的根节点1入队列，然后依次取出1并将其左右子节点2和3入队列，接着取出2并将其左右子节点4和5入队列，最后取出3并将其右子节点6入队列。按层次遍历的顺序依次输出了树的节点值。这样的层次遍历对于树的结构分析和广度优先搜索问题非常有用。