def test_size():
q = Queue(range(4))
for expected in range(4, 0, -1):
assert q.size() == expected
q.dequeue()
# queue is now empty
assert q.size() == 0
class testDequeue(unittest.TestCase):
def setUp(self):
self.q = Queue()
def testEmptyQueue(self):
self.assertRaises(IndexError, self.q.dequeue)
def testQueueOfOne(self):
self.q.enqueue(10)
self.assertEqual(self.q.dequeue(), 10)
self.assertEqual(self.q.head, None)
self.assertEqual(self.q.tail, None)
def testLongQueue(self):
self.q.enqueue(10)
self.q.enqueue(11)
self.q.enqueue(12)
self.q.enqueue(13)
self.q.enqueue(14)
self.q.enqueue(15)
self.assertEqual(self.q.dequeue(), 10)
self.assertEqual(self.q.head.val, 15)
self.assertEqual(self.q.tail.val, 11)
self.assertEqual(self.q.dequeue(), 11)
self.assertEqual(self.q.head.val, 15)
self.assertEqual(self.q.tail.val, 12)
def test_dequeue_empty_queue():
queue = Queue()
with pytest.raises(IndexError) as exc:
queue.dequeue()
assert str(exc.value) == "dequeue from empty queue"
def test_dequeue():
q = Queue()
for i in range(1, 4):
q.enqueue(i)
assert q.dequeue() == 1
assert q.dequeue() == 2
assert q.dequeue() == 3
class TestQueue(TestCase):
def setUp(self):
super().setUp()
self.queue = Queue()
def test_enqueue_dequeue(self):
self.queue.enqueue(1)
self.queue.enqueue(2)
self.assertEqual(self.queue.dequeue(), 1)
self.assertEqual(self.queue.dequeue(), 2)
def test_peek(self):
self.queue.enqueue(1)
self.queue.enqueue(2)
self.assertEqual(self.queue.peek(), 1)
self.assertEqual(self.queue.size(), 2)
def test_size(self):
self.queue.enqueue(1)
self.queue.enqueue(2)
self.assertEqual(self.queue.size(), 2)
def test_is_empty(self):
self.assertTrue(self.queue.is_empty())
self.queue.enqueue(1)
self.assertFalse(self.queue.is_empty())
self.queue.dequeue()
self.assertTrue(self.queue.is_empty())
def hotPotato(nameList, num):
"""
Return the name of the last person remaining after repetitive counting by num.
In this game children line up in a circle and pass an item from neighbor to neighbor as fast as they can.
At a certain point in the game, the action is stopped and the child who has the potato is removed from the circle.
Play continues until only one child is left.
INPUT
------
namelist : Players name
num : number of times item is passed
RETURN
------
player who is left after all iterations
"""
q = Queue(); numCount = 0
for i in range(len(nameList)):
q.enqueue(nameList[i])
while(q.size() > 1):
for i in range(num):
temp_removed_item = q.dequeue()
q.enqueue(temp_removed_item)
removed_item = q.dequeue()
print("Players remaining : ",q.items)
numCount += 1
return q.items[0]
def test_peek_post_dequeue():
q = Queue()
q.enqueue("apples")
q.enqueue("bananas")
q.dequeue()
actual = q.peek()
expected = "bananas"
assert actual == expected
def test_size_of_depopulated_queue(self):
"""Take the size of a queue that has been populated and then had
some items dequeued."""
q = Queue()
for val in self.values:
q.queue(val)
q.dequeue()
self.assertEqual(q.size(), len(self.values) - 1)
def test_dequeue_last_item_from_queue(self):
"""Dequeue a value from a queue that contains only one item."""
q = Queue()
self.assertTrue(q.head is None)
self.assertTrue(q.tail is None)
q.queue(self.single_value)
q.dequeue()
self.assertTrue(q.head is None)
self.assertTrue(q.tail is None)
def test_size():
q = Queue()
assert q.size() == 0
for i in range(1, 4):
q.enqueue(i)
assert q.size() == 3
q.dequeue()
assert q.size() == 2
q.dequeue()
assert q.size() == 1
def test_exhausted():
q = Queue()
q.enqueue("apple")
q.enqueue("banana")
q.enqueue("cucumber")
q.dequeue()
q.dequeue()
q.dequeue()
actual = q.is_empty()
expected = True
assert actual == expected
def test_dequeue():
u"""Asserts nodes are properly removed."""
q = Queue()
for val in value_tuple:
q.enqueue(val)
for val in value_tuple:
if q.list.head_node:
assert q.dequeue() == val
else:
with pytest.raises(LookupError):
q.dequeue()
def hot_potato(namelist, num):
sim_queue = Queue()
for name in namelist:
sim_queue.enqueue(name)
while sim_queue.size() > 1:
for i in range(num):
sim_queue.enqueue(sim_queue.dequeue())
print "removing %s" % sim_queue.dequeue()
return sim_queue.dequeue()
def test_peek():
q = Queue(range(4))
for _ in range(4):
expected = q.peek()
assert expected == q.dequeue()
# queue is now empty
assert q.peek() is None
def test_dequeue():
q = Queue()
q.enqueue("apple")
q.enqueue("banana")
actual = q.dequeue()
expected = "apple"
assert actual == expected
def test_dequeue():
queue = Queue()
queue.enqueue("a")
queue.enqueue("b")
assert queue.dequeue() == "a"
assert len(queue) == 1
def test_dequeue_when_full():
q = Queue()
q.enqueue("apples")
q.enqueue("bananas")
actual = q.dequeue()
expected = "apples"
assert actual == expected
def test_dequeue_from_populated_queue(self):
"""Dequeue a value from a populated queue."""
q = Queue()
q.queue(self.single_value)
dequeued = q.dequeue()
self.assertEqual(dequeued, self.single_value)
self.assertTrue(isinstance(dequeued, type(self.single_value)))
def test_dequeue(self):
queue = Queue()
queue.enqueue("item1")
assert len(queue) > 0
assert queue.front() == "item1"
dequeued_value = queue.dequeue()
assert dequeued_value == "item1"
assert len(queue) == 0
assert queue.front() == None
dequeued_value = queue.dequeue()
assert dequeued_value == None
assert len(queue) == 0
assert queue.front() == None
def test_queue_remove(self):
my_queue = Queue()
my_queue.enqueue(5)
my_queue.enqueue(7)
my_queue.enqueue(9)
deque_test = my_queue.dequeue()
self.assertEqual(5, deque_test,
"dequeue did not remove the first item")
def search_bfs(start_node):
q = Queue()
q.enqueue(start_node)
while not q.is_empty():
n = q.dequeue()
if not n.visited:
visit(n)
n.visited = True
for i in n.get_connections():
q.enqueue(i)
def _bfs(self):
search_queue = Queue()
search_queue.enqueue(self.source)
self.marked.add(self.source)
while not search_queue.is_empty():
current = search_queue.dequeue()
neighbors = self.graph.adjacent(current)
for neighbor in neighbors:
if neighbor not in self.marked:
search_queue.enqueue(neighbor)
self.marked.add(neighbor)
self.edge_to[neighbor] = current
def test_enqueue(self):
# Arrange
my_queue = Queue()
my_queue.enqueue(1)
my_queue.enqueue(2)
# Act
enqueue1 = my_queue.dequeue()
enqueue2 = my_queue.dequeue()
# Assert
self.assertEqual(2, enqueue1, "first enqueue did not match")
self.assertEqual(1, enqueue2, "second enqueue did not match")
def breadth_first(self):
queue = Queue()
collection = []
queue.enqueue(self.root)
while not queue.is_empty():
node = queue.dequeue()
collection.append(node.value)
for child in node.children:
queue.enqueue(child)
return collection
def bfs(g, start):
start.set_distance(0)
start.set_pred(None)
vq = Queue()
vq.enqueue(start)
while vq.size() > 0:
current_vert = vq.dequeue()
for nbr in current_vert.get_connections():
if nbr.get_color() == 'white':
nbr.set_color('gray')
nbr.set_distance(current_vert.get_distance() + 1)
nbr.set_pred(current_vert)
vq.enqueue(nbr)
current_vert.set_color('black')
def testQueue(self):
queue = Queue()
self.assertTrue(queue.isEmpty())
self.assertEqual(0, queue.size)
queue.enqueue(5)
self.assertFalse(queue.isEmpty())
self.assertEqual(1, queue.size)
queue.enqueue(6)
self.assertEqual(2, queue.size)
self.assertEqual(5, queue.dequeue())
self.assertEqual(1, queue.size)
self.assertEqual(6, queue.dequeue())
self.assertEqual(0, queue.size)
self.assertTrue(queue.isEmpty())
queue.enqueue(8)
queue.clear()
self.assertEqual(0, queue.size)
self.assertTrue(queue.isEmpty())
def test_dequeue(self):
# Arrange
my_queue = Queue()
my_queue.enqueue(1)
my_queue.enqueue(2)
# Act
dequeue1 = my_queue.dequeue()
dequeue2 = my_queue.dequeue()
# Assert
self.assertEqual(1, dequeue1, "The value is not correct")
self.assertEqual(2, dequeue2, "The value is not correct")
class testSize(unittest.TestCase):
def setUp(self):
self.q = Queue()
def testEmptyQueue(self):
self.assertEqual(self.q.size(), 0)
def testQueueOfOne(self):
self.q.enqueue(10)
self.assertEqual(self.q.size(), 1)
self.q.dequeue()
self.assertEqual(self.q.size(), 0)
def testLongQueue(self):
self.q.enqueue(10)
self.q.enqueue(11)
self.q.enqueue(12)
self.q.enqueue(13)
self.q.enqueue(14)
self.q.enqueue(15)
self.assertEqual(self.q.size(), 6)
self.q.dequeue()
self.q.dequeue()
self.assertEqual(self.q.size(), 4)
def add_values_to_empty_tree(tree, values):
"""
Helper function to add given values to BinaryTree
"""
tree.root = Node(values.pop())
q = Queue()
q.enqueue(tree.root)
while values:
node = q.dequeue()
node.left = Node(values.pop())
node.right = Node(values.pop()) if values else None
q.enqueue(node.left)
q.enqueue(node.right)
def find_path(graph, start_val, end_val):
ns = graph.get_node(start_val)
ne = graph.get_node(end_val)
q = Queue()
q.enqueue(ns)
found = False
while not q.is_empty() and not found:
n = q.dequeue()
for c in n.get_connections():
if not c.visited:
if c == ne:
found = True
else:
q.enqueue(c)
n.visited = True
return found
def breadth_first_search(graph: List[int], source_vertex: int,
target_vertex: int) -> List[int]:
vertices_to_visit = Queue()
vertices_to_visit.enqueue(source_vertex)
distances = {source_vertex: 0}
while not vertices_to_visit.is_empty():
current_vertex = vertices_to_visit.dequeue()
for neighbor in range(1, graph[current_vertex] + 1):
neighbor_index = current_vertex + neighbor
if neighbor_index < len(graph):
if neighbor_index not in distances:
distances[neighbor_index] = distances[current_vertex] + 1
if neighbor_index == target_vertex:
return distances[target_vertex]
vertices_to_visit.enqueue(neighbor_index)
def bfs(start):
"""
:param start: instance VertexForBFS
:return: None
"""
start.distance = 0
start.prev_vertex = None
vertex_queue = Queue()
vertex_queue.enqueue(start)
while vertex_queue.size() > 0:
current_vertex = vertex_queue.dequeue()
for nbr in current_vertex.get_connections():
if nbr.color == 'white':
nbr.color = 'gray'
nbr.distance = current_vertex.distance + 1
nbr.prev_vertex = current_vertex
vertex_queue.enqueue(nbr)
current_vertex.color = 'black'
def simulation(num_seconds, ppm):
printer = Printer(ppm)
print_queue = Queue()
waiting_times = []
for current_second in range(num_seconds):
if new_print_task():
task = Task(current_second)
print_queue.enqueue(task)
if not printer.busy() and not print_queue.is_empty():
next_task = print_queue.dequeue()
waiting_times.append(next_task.waitTime(current_second))
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()))
return average_wait
def breadth_first_traversal(self, start):
if start not in self.nodes():
raise KeyError
node = start
q = Queue()
q.enqueue(node)
traversed = []
while len(traversed) < len(self.nodes()):
try:
node = q.dequeue()
print node
traversed.insert(0, node)
children = self.neighbors(node)
for child in children:
if child not in traversed:
q.enqueue(child)
except LookupError:
break
traversed.reverse()
return traversed
def breadth_first_traversal(self, start):
if start not in self.nodes():
raise KeyError
node = start
q = Queue()
q.enqueue(node)
traversed = []
while len(traversed) < len(self.nodes()):
try:
node = q.dequeue()
print node
traversed.insert(0, node)
children = self.neighbors(node)
for child in children:
if child not in traversed:
q.enqueue(child)
except LookupError:
break
traversed.reverse()
return traversed
def bfs(adjList, start):
queue = Queue()
visited = {}
pred = {}
for key in adjList:
visited[key] = False
pred[key] = None
visited[start] = True
queue.enqueue(start)
while queue.size > 0:
vertex = queue.dequeue()
edges = adjList[vertex]
for edge in edges:
if visited[edge] is False:
visited[edge] = True
queue.enqueue(edge)
pred[edge] = vertex
return pred
def breadth_first_search(self, source_vertex, target_vertex):
visited = self._initialize_visited_set()
visited[source_vertex] = True
vertices_to_visit = Queue()
vertices_to_visit.enqueue(source_vertex)
history = {source_vertex: None}
path = []
while not vertices_to_visit.is_empty():
current_vertex = vertices_to_visit.dequeue()
if current_vertex == target_vertex:
break
for neighbor, _ in self.adjacency_list[current_vertex]:
if not visited[neighbor]:
visited[neighbor] = True
history[neighbor] = current_vertex
vertices_to_visit.enqueue(neighbor)
if target_vertex in history:
while target_vertex is not None:
path.insert(0, target_vertex)
target_vertex = history[target_vertex]
return path
from data_structures.queue import Queue
q = Queue(10)
print(repr(q))
for i in range(10):
q.enqueue(i + 1)
print(repr(q))
q.dequeue()
print(repr(q))
q.dequeue()
print(repr(q))
q.enqueue(-1)
print(repr(q))
for i in range(10):
q.dequeue()
print(repr(q))
def test_dequeue_not_empty(self):
my_queue = Queue()
my_queue.enqueue('4')
my_queue.enqueue('3')
my_queue.enqueue('2')
self.assertEqual('4', my_queue.dequeue())
def test_dequeue_empty(self):
my_queue = Queue()
self.failureException('Uh oh!! Queue is empty', my_queue.dequeue())
def test_enqueue(items):
q = Queue()
for item in items:
q.enqueue(item)
for item in items:
assert q.dequeue() == item
def test_dequeue(items):
q = Queue(items)
for item in items:
assert q.dequeue() == item
with pytest.raises(IndexError):
q.dequeue()
