def test_push():
queue = Queue()
assert (queue.is_empty())
for i in range(ITERS):
queue.push(i)
assert (len(queue) == i + 1)
assert (queue.peek() == 0)
assert (not queue.is_empty())
def BFS(self, src):
""" Performs Breadth First Search on self.graph from :src: node """
# Initialization
visited = [False
] * self.v # Whether the node i has been visited or not
d = [math.inf] * self.v # d[i] is distance from src to node i
p = [None] * self.v # p[i] is parent of node i in the traversal
traversal_order = [] # Final traversal order
q = Queue(self.v)
visited[src] = True
d[src] = 0
q.enqueue(src)
while not q.is_empty():
u = q.dequeue()
traversal_order.append(u)
adj = self.graph[u].head
while adj != None: # Adj vertices
v = adj.val[0] # Vertex
if not visited[v]:
visited[v] = True
d[v] = d[u] + 1
p[v] = u
q.enqueue(v)
adj = adj.next
return traversal_order, d, p
def _BFS(self, source=None, sink=None, nodes=None):
"""Breadth first search (BFS).
Finds a path between source and sink and returns it. If no path is found returns false"""
if source is None:
source = self.source
if sink is None:
sink = self.sink
if nodes is None:
nodes = self.nodes
for node in nodes:
node.visited = False
q = Queue()
q.enqueue(source)
source.visited = True
while not q.is_empty():
current_node = q.dequeue()
children = current_node.children
for i in range(len(children)):
child = children[i]
if current_node.name.lower() == "source":
residual_capacity = current_node.residual_capacity[i]
else:
residual_capacity = child.residual_capacity
if child.name == sink.name:
return self._extract_path_from_bfs(current_node, source,
sink)
if not child.visited and residual_capacity > 0:
child.visited = True
child.parent = current_node
q.enqueue(child)
return False # no path found
def test_pop():
queue, arr = Queue(), []
assert (queue.is_empty())
with pytest.raises(AssertionError):
queue.pop()
for _ in range(ITERS):
value = random.randrange(MAX_VAL)
queue.push(value)
arr.append(value)
assert (len(queue) == len(arr))
for _ in range(ITERS):
assert (not queue.is_empty())
expected, arr = arr[0], arr[1:]
actual = queue.peek()
assert (actual == expected)
actual = queue.pop()
assert (actual == expected)
assert (len(queue) == len(arr))
assert (queue.is_empty())
with pytest.raises(AssertionError):
queue.pop()
def test_queue():
f = Queue()
test_array = [i for i in range(100)]
for i in test_array:
f.enqueue(i)
result = []
while not f.is_empty():
result.append(f.deque())
assert test_array == result
def bfs(graph: Graph, start_node: str, target_node: str, visited_nodes: set):
queue = Queue()
queue.enqueue(start_node)
while not queue.is_empty():
current = queue.deque()
if current == target_node:
return True
adj = graph.get_edges_node(current)
for node in adj:
if node not in visited_nodes:
queue.enqueue(node)
visited_nodes.add(current)
return False
def simulation(seconds, ppm):
printer = Printer(ppm)
print_queue = Queue()
waiting_times = []
for sec in range(seconds):
if is_new_task():
task = Task(sec)
print_queue.enqueue(task)
if not printer.busy() and not print_queue.is_empty():
next_task = print_queue.dequeue()
waiting_times.append(next_task.wait_time(sec))
printer.start_next(next_task)
printer.tick()
average_wait = sum(waiting_times) / len(waiting_times)
print("Average Wait %6.2f secs %3d tasks remaining." %
(average_wait, print_queue.size()))
def simulation(num_seconds, pages_per_minute, num_students):
lab_printer = Printer(pages_per_minute)
print_queue = Queue()
waiting_times = []
for current_second in range(num_seconds):
if new_print_task(num_students):
task = Task(current_second)
print_queue.enqueue(task)
if (not lab_printer.busy()) and (not print_queue.is_empty()):
nexttask = print_queue.dequeue()
waiting_times.append(nexttask.wait_time(current_second))
lab_printer.start_next(nexttask)
lab_printer.tick()
average_wait = sum(waiting_times) / len(waiting_times)
print("Average Wait %6.2f secs %3d tasks remaining." %
(average_wait, print_queue.size()))
def test_enqueue_item():
q = Queue()
q.enqueue(1)
assert q.is_empty() is False
