python deque 遍历
时间: 2023-10-22 09:23:13 浏览: 102
你可以使用 `for` 循环来遍历一个 `deque`,也可以使用 `while` 循环和 `popleft()` 方法来遍历它。
使用 `for` 循环:
```python
from collections import deque
my_deque = deque([1, 2, 3, 4, 5])
for item in my_deque:
print(item)
```
使用 `while` 循环和 `popleft()` 方法:
```python
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中二叉树的遍历方法:
1. 深度优先遍历(DFS):
深度优先遍历是一种先访问根节点,然后递归地访问左子树和右子树的方式。具体实现可以使用递归或者栈来实现。
```python
class BinTree:
# 构造函数
def __init__(self, data, left=None, right=None):
self.data = data
self.left = left
self.right = right
# 深度优先遍历
def dfs(self):
if self is None:
return []
result = []
result.append(self.data)
if self.left:
result += self.left.dfs()
if self.right:
result += self.right.dfs()
return result
# 创建二叉树
tree = BinTree('A', BinTree('B'), BinTree('C', BinTree('D', BinTree('F'), BinTree('G')), BinTree('E', BinTree('H'), BinTree('I'))))
# 深度优先遍历
dfs_result = tree.dfs()
print(dfs_result) # 输出:['A', 'B', 'C', 'D', 'F', 'G', 'E', 'H', 'I']
```
2. 宽度优先遍历(BFS):
宽度优先遍历是一种逐层访问二叉树节点的方式。具体实现可以使用队列来实现。
```python
from collections import deque
class BinTree:
# 构造函数
def __init__(self, data, left=None, right=None):
self.data = data
self.left = left
self.right = right
# 宽度优先遍历
def bfs(self):
if self is None:
return []
result = []
queue = deque()
queue.append(self)
while queue:
node = queue.popleft()
result.append(node.data)
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
return result
# 创建二叉树
tree = BinTree('A', BinTree('B'), BinTree('C', BinTree('D', BinTree('F'), BinTree('G')), BinTree('E', BinTree('H'), BinTree('I'))))
# 宽度优先遍历
bfs_result = tree.bfs()
print(bfs_result) # 输出:['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']
```
广度优先遍历python
广度优先遍历(BFS)是一种图形搜索算法,它从根节点开始,逐层遍历整张图,按照距离从近到远的顺序依次访问节点。在Python中,可以使用队列来实现BFS算法。具体实现步骤如下:
1. 创建一个空队列,并将根节点入队。
2. 当队列不为空时,取出队首节点,并将其所有未访问过的邻居节点入队。
3. 标记当前节点为已访问。
4. 重复步骤2和3,直到队列为空。
下面是一个简单的Python代码实现:
```python
from collections import deque
def bfs(graph, root):
visited = set() # 用集合记录已访问的节点
queue = deque([root]) # 创建一个空队列,并将根节点入队
visited.add(root) # 标记根节点为已访问
while queue: # 当队列不为空时
node = queue.popleft() # 取出队首节点
print(node) # 访问当前节点
for neighbor in graph[node]: # 遍历当前节点的所有邻居节点
if neighbor not in visited: # 如果邻居节点未被访问过
visited.add(neighbor) # 标记邻居节点为已访问
queue.append(neighbor) # 将邻居节点入队
# 测试代码
graph = {
'A': ['B', 'C'],
'B': ['A', 'D', 'E'],
'C': ['A', 'F'],
'D': ['B'],
'E': ['B', 'F'],
'F': ['C', 'E']
}
bfs(graph, 'A')
```
输出结果为:
```
A
B
C
D
E
F
```