class AnimalQueue(object):
def __init__(self):
self.dogs = Queue()
self.cats = Queue()
self.order = 0
def enqueue(self, animal):
animal.order = self.order
self.order += 1
if isinstance(animal, Dog):
self.dogs.enqueue(animal)
if isinstance(animal, Cat):
self.cats.enqueue(animal)
def dequeue_any(self):
if self.dogs.queue_empty():
return self.dequeue_cat()
elif self.cats.queue_empty():
return self.dequeue_dog()
elif self.dogs.peek().order < self.cats.peek().order:
return self.dequeue_dog()
else:
return self.dequeue_cat()
def dequeue_dog(self):
return self.dogs.dequeue()
def dequeue_cat(self):
return self.cats.dequeue()
def queue_operations():
'''USER OPERATIONS OF A QUEUE IMPLEMENTATION'''
queue = Queue()
while choice > 0:
queue_menu = [('MAIN MENU', -1), ('EXIT', 0), \
('ENQUEUE', 1), ('DEQUEUE', 2), ('FRONT', 3), ('REAR', 4), ('SIZE', 5)]
print_menu(queue_menu)
choice = int(input().strip())
if choice == 1:
print('ENTER ITEM :', end=' ')
queue.enqueue(int(input().strip()))
print('ENQUEUE OPERATION SUCCESSFUL.')
elif choice == 2:
if queue.is_empty():
print('UNDERFLOW')
else:
print('DEQUEUED VALUE :', queue.dequeue())
elif choice == 3:
if queue.is_empty():
print('UNDERFLOW')
else:
print('FRONT :', queue.front())
elif choice == 4:
if queue.is_empty():
print('UNDERFLOW')
else:
print('REAR :', queue.rear())
elif choice == 5:
print('QUEUE SIZE :', queue.size())
def test_clear():
myQ = Queue()
myQ.enqueue(3)
myQ.enqueue(4)
myQ.clear()
assert myQ.size() == 0
assert myQ.isEmpty()
assert myQ.toList() == []
def hotPotato(names, num):
simQueue = Queue()
for name in names:
simQueue.enqueue(name)
while simQueue.size() > 1:
for i in range(num):
simQueue.enqueue(simQueue.dequeue())
simQueue.dequeue()
return simQueue.dequeue()
def hotpotato(names, num):
circular_queue = Queue()
for name in names:
circular_queue.enqueue(name)
while circular_queue.size() > 1:
for k in range(num - 1):
circular_queue.enqueue(circular_queue.dequeue())
circular_queue.dequeue()
print circular_queue.dequeue()
def bfs_paths(graph, source, destination):
'''ALL POSSIBLE PATHS FROM SOURCE TO DESTINATION USING BREADTH-FIRST SEARCH'''
queue = Queue()
queue.enqueue((source, [source]))
while not queue.is_empty():
(vertex, path) = queue.dequeue()
for next_node in graph[vertex].keys():
if next_node == destination:
yield path + [next_node]
else:
queue.enqueue((next_node, path + next_node))
def play(players, rounds):
'''
Play hot potato game
'''
que = Queue()
for player in players:
que.enqueue(player)
while que.size() > 1:
for _ in range(rounds):
que.enqueue(que.dequeue())
que.dequeue()
print("Last player in the filed : {} ".format(que.dequeue()))
def bfs(graph, source):
'''BREADTH-FIRST SEARCH'''
queue = Queue()
visited, distance = set(), {}
distance[source] = 0
queue.enqueue(source)
visited.add(source)
while not queue.is_empty():
u = queue.dequeue()
for v in graph[u].keys():
if v not in visited:
visited.add(v)
distance[v] = distance[u] + 1
queue.enqueue(v)
return distance
def exists_route_bfs(directed_graph, u, v):
"""Returns True if there exist a route between nodes u and v
in directed_graph. Uses BFS.
"""
if u is v:
return True
for w in directed_graph:
w.discovered = False
q = Queue()
q.enqueue(u)
u.discovered = True
while not q.queue_empty():
u = q.dequeue()
for neighbour in u.neighbours:
if not neighbour.discovered:
if neighbour is v:
return True
q.enqueue(neighbour)
neighbour.discovered = True
return False
def simulation(timeInsec, ppm):
printer = Printer(ppm)
printQueue = Queue()
waitingTImes = []
for second in range(timeInsec):
if newPrintTask():
task = Task(second)
printQueue.enqueue(task)
if (not printer.busy()) and (not printQueue.isEmpty()):
nexttask = printQueue.dequeue()
waitingTImes.append(nexttask.waitTime(second))
printer.startNext(nexttask)
printer.tick()
averageWait = sum(waitingTImes) / len(waitingTImes)
print("Average Wait %6.2f secs %3d tasks remaining." %
(averageWait, printQueue.size()))
def levelorder(self):
myq = Queue()
myq.enqueue(self)
while not myq.isEmpty():
cur = myq.dequeue()
yield cur.data
myq.enqueue(cur.left) if cur.left else ()
myq.enqueue(cur.right) if cur.right else ()
def subtree(r1, r2):
q = Queue()
q.enqueue(r1)
while not q.queue_empty():
x = q.dequeue()
if x.key == r2.key and same_tree(x, r2):
return True
if x.left is not None:
q.enqueue(x.left)
if x.right is not None:
q.enqueue(x.right)
return False
class TestQueueMethods(unittest.TestCase):
def setUp(self):
# Setup
self.q = Queue(1)
self.q.enqueue(2)
self.q.enqueue(3)
return
def tearDown(self):
#Clear For Next Test
self.q = None
def test_peek(self):
self.assertEqual(self.q.peek(), 1)
pass
def test_enqueue(self):
self.q.enqueue(4)
self.assertEqual(self.q.peek(),1)
pass
def test_deque(self):
self.assertEqual(self.q.dequeue(),1)
self.assertEqual(self.q.dequeue(),2)
self.assertEqual(self.q.dequeue(),3)
pass
def test_total(self):
self.assertEqual(self.q.dequeue(),1)
self.q.enqueue(4)
self.assertEqual(self.q.dequeue(),2)
self.assertEqual(self.q.dequeue(),3)
self.assertEqual(self.q.dequeue(),4)
self.q.enqueue(5)
self.assertEqual(self.q.peek(),5)
pass
def same_tree2(root1, root2):
q = Queue()
q.enqueue(root1)
q.enqueue(root2)
while not q.queue_empty():
x, y = q.dequeue(), q.dequeue()
if x.key != y.key:
return False
if x.left is not None and y.left is not None:
q.enqueue(x.left)
q.enqueue(y.left)
elif x.left is not y.left:
return False
if x.right is not None and y.right is not None:
q.enqueue(x.right)
q.enqueue(y.right)
elif x.right is not y.right:
return False
return True
def test_enqueue_for_empty_queue(self):
empty_queue = Queue()
person1 = "person1"
empty_queue.enqueue(person1)
self.assertEqual("person1", empty_queue.head.value,
empty_queue.tail.value)
def test_enqueue_dequeue():
myQ = Queue()
myQ.enqueue(2)
assert myQ.dequeue() == 2
def test_toList():
myQ = Queue()
myQ.enqueue(3)
myQ.enqueue(4)
assert myQ.toList() == [4, 3]
def test_size():
myQ = Queue()
myQ.enqueue(2)
assert myQ.size() == 1
