def test_size(self):
q = Queue()
self.assertEqual(q.size(), 0, "The size of empty Queue q is not 0.")
q.enqueue(4)
self.assertEqual(
q.size(), 1,
"The size of Queue q doesn't expand to 1 after enqueuing element "
+ "4.")
q.enqueue("dog")
self.assertEqual(
q.size(), 2,
"The size of Queue q doesn't expand to 2 after enqueuing element "
+ "'dog'.")
q.dequeue()
self.assertEqual(
q.size(), 1,
"The size of Queue q doesn't shrink to 1 after dequeuing once.")
q.dequeue()
self.assertEqual(
q.size(), 0,
"The size of Queue q doesn't shrink to 0 after dequeuing twice.")
class Stack:
def __init__(self):
self.queue1 = Queue()
self.queue2 = Queue()
def push(self, value):
if self.queue1.is_empty() and self.queue2.is_empty():
self.queue1.enqueue(value)
elif not self.queue1.is_empty() and self.queue2.is_empty():
self.queue1.enqueue(value)
elif self.queue1.is_empty() and not self.queue2.is_empty():
self.queue2.enqueue(value)
# 不会两个都不空的，因为出栈的操作能够保证肯定至少有一个 queue 是空的
def pop(self):
if not self.queue1.is_empty():
if self.queue1.size() == 1:
return self.queue1.dequeue()
else:
while self.queue1.size() > 1:
self.queue2.enqueue(self.queue1.dequeue())
return self.queue1.dequeue()
else:
if not self.queue2.is_empty():
if self.queue2.size() == 1:
return self.queue2.dequeue()
else:
while self.queue2.size() > 1:
self.queue1.enqueue(self.queue2.dequeue())
return self.queue2.dequeue()
class Test_Queue(unittest.TestCase):
def setUp(self):
self.q = Queue()
def test_init(self):
self.assertEqual(0, self.q.size())
def test_is_empty(self):
self.assertEqual(0, self.q.size())
def test_enqueue(self):
self.q.enqueue(3)
self.assertEqual(1, self.q.size())
def test_dequeue(self):
self.q.enqueue(9)
self.assertEqual(9, self.q.dequeue())
def test_peek(self):
self.q.enqueue(2)
self.q.enqueue(3)
self.assertEqual(2, self.q.peek())
def test_size(self):
self.q.enqueue(1)
self.q.enqueue(3)
self.assertEqual(2, self.q.size())
def stack_using_queue():
q1 = Queue()
q2 = Queue()
choice = 1
while (choice != 0):
print("1. Push")
print("2. Pop")
choice = int(input(">"))
if choice == 1:
continue_add = 'y'
while (continue_add != 'n'):
q1.enqueue(input("Enter the item: "))
continue_add = input("Continue (y/n): ")
elif choice == 2:
if not q1.isEmpty():
for k in range(0, q1.size() - 1):
q2.enqueue(q1.dequeue())
print("The popped element is: {}".format(q1.dequeue()))
for t in range(0, q2.size()):
q1.enqueue(q2.dequeue())
else:
print("Queue empty")
def test_queue_dequeue_enqueue():
"""Test ability to enqueue after dequeue."""
test_case = Queue(TEST_QUEUE_DATA)
assert test_case.dequeue() == [1, 2, 3, 4, 5]
assert test_case.size() == 4
test_case.enqueue("stripes")
assert test_case.size() == 5
class Stack:
def __init__(self):
self.mainQueue = Queue()
self.scratchQueue = Queue()
def push(self, element):
self.mainQueue.enqueue(element)
def pop(self):
assert self.size() > 0, 'Stack is empty'
# Now the "fun" part, we need to get the element at the back of the queue
while self.mainQueue.size(
) > 1: # will exit when only one element left
tmp = self.mainQueue.dequeue() # get it out of one
self.scratchQueue.enqueue(tmp) # put it in the other
element = self.mainQueue.dequeue()
# Now, the first element of the queue went into scratch, then the
# second, and so on. That means the order of the elements has
# remained unchanged. If we swap the labels of the queues, then
# we'll be back where we started, minus the element at the back
# of the queue
self.mainQueue, self.scratchQueue = self.scratchQueue, self.mainQueue
return element
def size(self):
return self.mainQueue.size()
def test_size(self):
q = Queue()
self.assertEqual(q.size(), 0)
q.enqueue('a')
q.enqueue('b')
q.enqueue('c')
self.assertEqual(q.size(), 3)
def test_size(self):
q = Queue()
self.assertEquals(q.size(), 0)
q.enqueue(1)
q.enqueue('a')
q.enqueue('bob')
q.enqueue(1.0)
self.assertEquals(q.size(), 4)
def test_enqueueInEmptyQueue(self):
queue = Queue()
queue.enqueue(5)
self.assertEqual(queue.size(), 1)
queue.enqueue(11)
self.assertEqual(queue.size(), 2)
queue.enqueue(44)
self.assertEqual(queue.size(), 3)
class EnqueueInEmptyQueue(unittest.TestCase):
def setUp(self) -> None:
self.q = Queue()
def test(self):
self.assertEqual(0, self.q.size())
self.q.enqueue(1)
self.assertEqual(1, self.q.size())
self.assertEqual(1, self.q.dequeue())
def test_size():
q= Queue()
for i in range(100):
q.enqueue(i)
assert q.size()== 100
for j in range(50):
q.dequeue()
assert q.size()== 50
def test_size(self):
q = Queue()
self.assertEqual(q.size(), 0)
q.enqueue(1)
self.assertEqual(q.size(), 1)
q.enqueue("fish")
self.assertEqual(q.size(), 2)
q.enqueue(2)
self.assertEqual(q.size(), 3)
def test_size():
q = Queue()
for i in range(100):
q.enqueue(i)
assert q.size() == 100
for j in range(50):
q.dequeue()
assert q.size() == 50
def main(): q = Queue() q.isEmpty() q.enqueue(9) q.enqueue(2) q.enqueue(3) q.isEmpty() q.size() q.peek() q.print_list()
def main():
q = Queue()
q.isEmpty()
q.enqueue(9)
q.enqueue(2)
q.enqueue(3)
q.isEmpty()
q.size()
q.peek()
q.print_list()
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 hot_potato(name_list, num):
sim_queue = Queue()
for name in name_list:
sim_queue.enqueue(name)
while sim_queue.size() > 1:
for i in range(num):
bible = sim_queue.dequeue()
print(sim_queue.size(),bible)
sim_queue.enqueue(bible)
sim_queue.dequeue()
return sim_queue.dequeue()
def test_enqueue(self):
queue = Queue()
queue.enqueue(11)
self.assertEqual(queue.get_all(), [11])
self.assertEqual(queue.size(), 1)
self.assertEqual(queue.peek(), 11)
queue.enqueue(22)
self.assertEqual(queue.get_all(), [11, 22])
self.assertEqual(queue.size(), 2)
self.assertEqual(queue.peek(), 11)
class EnqueueInNotEmptyQueue(unittest.TestCase):
def setUp(self) -> None:
self.q = Queue()
for i in range(0, 10):
self.q.enqueue(i)
def test(self):
self.assertEqual(10, self.q.size())
self.q.enqueue(10)
self.assertEqual(11, self.q.size())
for i in range(0, 11):
self.assertEqual(i, self.q.dequeue())
class QueueTestCase(unittest.TestCase):
def setUp(self):
self.queue = Queue()
def test_isEmpty(self):
self.assertEqual(self.queue.isEmpty(),True)
def test_queue(self):
self.queue.enqueue(12)
self.queue.enqueue('queue')
self.queue.enqueue('end')
self.assertEqual(self.queue.size(),3)
self.assertEqual(self.queue.dequeue(),12)
self.assertEqual(self.queue.dequeue(),'queue')
self.assertEqual(self.queue.size(),1)
class TestQueue(unittest.TestCase):
def setUp(self):
self.q = Queue()
def test_all(self):
self.assertTrue(self.q.isEmpty())
self.q.enqueue(4)
self.q.enqueue('dog')
self.q.enqueue(True)
self.assertEqual(3, self.q.size())
self.assertFalse(self.q.isEmpty())
self.q.enqueue(8.4)
self.assertEqual(4, self.q.dequeue())
self.assertEqual('dog', self.q.dequeue())
self.assertEqual(2, self.q.size())
def simulate_line(till_show, max_time, num_cus):
pq = Queue()
tix_sold = []
for i in range(1, num_cus + 1):
pq.enqueue("person_" + str(i))
print("--- Show waiting customers ---")
i = pq.size() - 1
while i >= 0:
print(pq.showqueue(i))
i -= 1
print("--- end ---\n")
t_end = time.time() + till_show
now = time.time()
while (now < t_end) and (not pq.is_empty()):
now = time.time() # get time now
r = random.randint(0, max_time)
time.sleep(r)
person = pq.dequeue()
print("{} waits for {} sec to get in.".format(person, r))
tix_sold.append(person)
i += 1
return tix_sold
def connect(self, root):
if (root == None):
return
q = Queue()
q.put(root)
while (not q.empty()):
size = q.size()
pre = q.get()
if (pre.left != None):
q.put(pre.left)
if (pre.right != None):
q.put(pre.right)
for i in range(size):
if (i == 0):
continue
cur = q.get()
if (cur.left != None):
q.put(cur.left)
if (cur.right != None):
q.put(cur.right)
pre.right = cur
pre = cur
pre.right = None
def test_dequeue_multi():
queue = Queue()
queue.enqueue("Bacon")
queue.enqueue("Beer")
assert queue.dequeue() == "Bacon"
assert queue.first_item.data == "Beer"
assert queue.size() == 1
def bfs(g, start): # it takes in a graph and the start point
start.setDistance(0)
start.setPred(None)
vertQueue = Queue()
vertQueue.enqueue(start)
while (vertQueue.size() > 0):
currentVert = vertQueue.dequeue(
) # Start exploring the vertices at the front of the queue by iterating/dequeueing. Each time the element color is checked
for nbr in currentVert.getConnections():
if (
nbr.getColor() == 'white'
): #if the vertex is unexplored, 4 things happen. All the vertices are initialized to white when they are constructed
nbr.setColor(
'gray'
) # The new unexplored vertex is colored gray, when the vertex is first initially discovered
nbr.setDistance(
currentVert.getDistance() + 1
) #the distance to nbr is set to the distance to the currentVert+1
nbr.Pred(currentVert
) #the predessesor of nbr is set to the currentVert
vertQueue.enqueue(
nbr
) #adding nbr to the end of the queue which makes it be available for further exploration
currentVert.setColor(
'black'
) # When the vertex is completely explored, then its colored black
def test_size(li, result):
"""Test size method."""
from queue import Queue
new_list = Queue()
for item in li:
new_list.enqueue(item)
assert result == new_list.size()
def simulation(numSeconds, pagesPerMinute):
"""
打印任务模拟
Args:
numSeconds:numSeconds 时间内模拟打印
pagesPerMinute:打印速度 pages/min
"""
labprinter = Printer(pagesPerMinute)
printQueue = Queue()
waitingtimes = []
for currentSecond in range(numSeconds):
if newPrintTask():
task = Task(currentSecond)
printQueue.enqueue(task)
#打印机空闲且队列不为空
if (not labprinter.busy()) and (not printQueue.isEmpty()):
#下一个任务
nexttask = printQueue.dequeue()
waitingtimes.append(nexttask.waitTime(currentSecond))
labprinter.startNext(nexttask)
labprinter.tick()
averageWait = sum(waitingtimes) / len(waitingtimes)
print("Average wait %6.2f secs %3d tasks remaining." %
(averageWait, printQueue.size()))
def test_dequeue(self):
queue = Queue()
queue.enqueue(11)
queue.enqueue(22)
self.assertEqual(queue.get_all(), [11, 22])
res = queue.dequeue()
self.assertEqual(queue.get_all(), [22])
self.assertEqual(res, 11)
self.assertEqual(queue.size(), 1)
self.assertEqual(queue.peek(), 22)
res = queue.dequeue()
self.assertEqual(queue.get_all(), [])
self.assertEqual(res, 22)
self.assertEqual(queue.size(), 0)
def testEmpty():
q = Queue()
testData = getRandom(10)
for item in testData:
q.pushBack(item)
q.empty()
assert q.size() == 0
def bft(player):
q = Queue()
visited = set()
q.enqueue([("s", player.current_room.id)
]) # Enqueue the starting vertex with its direction
while q.size() > 0:
path = q.dequeue()
cur_room = path[-1] # last vertex from the path
if player.current_room not in visited:
visited.add(player.current_room.id)
# Iterate through the exits
for direction in world.rooms[cur_room[1]].get_exits():
# Check if cur_rooms neighbor is in unexplored (global)
if world.rooms[cur_room[1]].get_room_in_direction(
direction) not in unexplored:
# Add (room.id, direction)
path.append((direction, world.rooms[
cur_room[1]].get_room_in_direction(direction).id))
print(path)
return path
# Check if cur_rooms neighbor.id is in visited (intern)
if world.rooms[cur_room[1]].get_room_in_direction(
direction).id not in visited:
new_room = world.rooms[cur_room[1]].get_room_in_direction(
direction)
new_path = path.copy()
# Add room with direction & Id
new_path.append((direction, new_room.id))
visited.add(new_room.id)
q.enqueue(new_path)
def simulation(numOfStd, pagePerMinute):
labPrinter = Printer(pagePerMinute)
printerQueue = Queue()
waitingTimes = []
currentSecond = 0
taskCnt = numOfStd * 2
while True:
if newPrintTask() and taskCnt > 0:
printerQueue.enqueue(Task(currentSecond))
taskCnt -= 1
if not labPrinter.busy() and not printerQueue.isEmpty():
nextTask = printerQueue.dequeue()
waitingTimes.append(nextTask.waitTime(currentSecond))
labPrinter.startNext(nextTask)
if taskCnt == 0 and not labPrinter.busy() and printerQueue.isEmpty():
break
labPrinter.tick()
currentSecond += 1
avgWait = sum(waitingTimes) / len(waitingTimes)
print("Average Wait %6.2f seconds %3d tasks ramaining"%(avgWait, printerQueue.size()))
def test_queue_enqueue_dequeue_from_empty():
"""Test ability to enqueue to empty queue and dequeueu same node."""
test_case = Queue()
test_case.enqueue("stripes")
assert test_case.dll.head.data == "stripes"
assert test_case.dequeue() == "stripes"
assert test_case.size() == 0
def bfs(g, start, end):
vertex_queue = Queue()
vertex_queue.enqueue(start)
visited = set()
visited.add(start.id)
curr_vertex = None
while vertex_queue.size() > 0:
curr_vertex = vertex_queue.dequeue()
if curr_vertex.id == end.id:
break
# print(curr_vertex.id, curr_vertex.getNeighbors())
for nbr in curr_vertex.getNeighbors():
if nbr in visited:
continue
v = g.getVertex(nbr)
v.prev_vertex = curr_vertex
vertex_queue.enqueue(v)
visited.add(curr_vertex.id)
print('visited size', len(visited))
print('========')
while curr_vertex is not None:
print(curr_vertex.id)
curr_vertex = curr_vertex.prev_vertex
def bfs_map(graph, starting_room):
queue = Queue()
visited = set()
queue.enqueue([starting_room])
while queue.size():
path = queue.dequeue()
rooms = path[-1]
if rooms not in visited:
visited.add(rooms)
for room in graph[rooms]:
if graph[rooms][room] == '?':
return path
for adjacent_rooms in graph[rooms]:
surrounding_rooms = graph[rooms][adjacent_rooms]
new_path = list(path)
new_path.append(surrounding_rooms)
queue.enqueue(new_path)
def test_size(li, result):
"""Test size method."""
from queue import Queue
new_list = Queue()
for item in li:
new_list.enqueue(item)
assert result == new_list.size()
class QueueTest(unittest.TestCase):
def setUp(self):
self.myqueue = Queue()
def tearDown(self):
del(self.myqueue)
def test_create_empty_queue(self):
self.assertEqual(self.myqueue.isEmpty(), True)
def test_enqueue_element(self):
self.myqueue.enqueue(1)
self.assertEqual(self.myqueue.items[0], 1)
def test_dequeue_element(self):
self.myqueue.items.append(1)
self.assertEqual(self.myqueue.dequeue(), 1)
def test_ordering_enqueue_dequeue(self):
self.myqueue.enqueue(1)
self.myqueue.enqueue(2)
self.assertEqual(self.myqueue.dequeue(), 1)
self.assertEqual(self.myqueue.dequeue(), 2)
def test_queue_size(self):
self.myqueue.enqueue(1)
self.myqueue.enqueue(2)
self.myqueue.enqueue(3)
self.assertEqual(self.myqueue.size(), 3)
def simulation(seconds, ppm):
printer = Printer(ppm)
q = Queue()
waittimes = []
for currentSecond in range(seconds):
if newPrintTask():
task = Task(currentSecond)
q.enqueue(task)
if (not printer.isBusy()) and (not q.isEmpty()):
nextTask = q.dequeue()
waittimes.append(nextTask.getTimeWaited(currentSecond))
printer.startNextTask(nextTask)
printer.countdown()
averageWait = sum(waittimes)/len(waittimes)
print "Average wait of %6.2f seconds; %3d tasks remaining." \
% (averageWait, q.size())
return
class TestQueue(unittest.TestCase): def setUp(self): self.obj = Queue() def tearDown(self): self.obj = Queue() def test_empty_queue(self): self.assertTrue(self.obj.is_empty()) def test_raises_queue_empty_error(self): self.assertRaises(QueueEmptyError, lambda: self.obj.dequeue()) def test_queue_size(self): size = 20 for i in range(size): self.obj.enqueue(i) self.assertEqual(self.obj.size(), size) def test_queue_top_item(self): size = 20 for i in range(size): self.obj.enqueue(i) self.assertEqual(self.obj.dequeue(), 0)
def test_size():
"""Test if the size method works."""
from queue import Queue
my_queue = Queue()
my_queue.enqueue('monkey')
my_queue.enqueue('chicken')
my_queue.enqueue('baby')
assert my_queue.size() == 3
def play_hot_potato(players):
# put players in queue
queue = Queue()
for player in players:
queue.enqueue(player)
# play the game until we have one winner
while queue.size() > 1:
# pass a random number of times
num_of_passes = random.randint(1, 5*queue.size())
for i in range(num_of_passes):
# pass
queue.enqueue(queue.dequeue())
# remove the person holding the potato
queue.dequeue()
# return winner
return queue.dequeue()
def test_size_with_remove():
queue = Queue()
queue.enqueue("Bacon")
queue.enqueue("Beer")
queue.enqueue("Cow")
queue.enqueue("Whiskey")
queue.dequeue()
assert queue.size() == 3
def test_Queue_dequeue(self):
q1 = Queue()
q1.enqueue(0)
q1.enqueue(1.2)
q1.enqueue("3.4")
q1.enqueue([5, 6])
q1.enqueue((7, 8))
q1.enqueue({9, 10})
self.assertEqual(q1.size(), 6)
self.assertEqual(q1.dequeue(), 0)
self.assertEqual(q1.size(), 5)
self.assertEqual(q1.dequeue(), 1.2)
self.assertEqual(q1.size(), 4)
self.assertEqual(q1.dequeue(), "3.4")
self.assertEqual(q1.size(), 3)
self.assertEqual(q1.dequeue(), [5, 6])
self.assertEqual(q1.size(), 2)
self.assertEqual(q1.dequeue(), (7, 8))
self.assertEqual(q1.size(), 1)
self.assertEqual(q1.dequeue(), {9, 10})
self.assertEqual(q1.size(), 0)
with self.assertRaises(ValueError):
q1.dequeue()
def hotPotato(list, num):
Q = Queue()
for i in list:
Q.enqueue(i)
while Q.size() !=1:
for j in xrange(num):
Q.enqueue(Q.dequeue())
Q.dequeue()
return Q.dequeue()
def test_size():
"""
The size of the queue should be accurately pollable
"""
queue = Queue()
queue.enqueue(500)
queue.enqueue(600)
queue.enqueue(700)
assert queue.size() == 3
def hot_potato(name_list, num):
sim_queue = Queue()
for name in name_list:
sim_queue.enqueue(name)
while sim_queue.size() > 1:
for i in range(num):
sim_queue.enqueue(sim_queue.dequeue()) # loop
sim_queue.dequeue() # elminated
return sim_queue.dequeue()
def hot_potato(namelist,num):
s=Queue()
for name in namelist:
s.enqueue(name)
while s.size()>1:
for i in range(num):
s.enqueue(s.dequeue())
s.dequeue()
return s.dequeue()
def breadth_first(self):
"""Traverse tree with breadth-first traversal."""
q = Queue()
q.enqueue(self)
while q.size() > 0:
tree = q.dequeue()
if tree.value is not None:
yield tree.value
for child in tree._children():
q.enqueue(child)
def breadth_first_traversal(self):
q = Queue()
q.enqueue(self.root)
while q.size() > 0:
current = q.dequeue()
yield current.value
if current.left:
q.enqueue(current.left)
if current.right:
q.enqueue(current.right)
def hotPotato(namelist, num):
simqueue = Queue()
for name in namelist:
simqueue.enqueue(name)
while simqueue.size() > 1:
for i in range(num):
simqueue.enqueue(simqueue.dequeue())
simqueue.dequeue()
return simqueue.dequeue()
def main():
my = Queue()
while 1:
command = input("Add, Serve, or Exit:")
if command == "Add":
print("%s"%my.size())
if my.size() > 2:
print ("You cannot add more people, the lineup is full!")
else:
name = input("enter the name of the person to add:")
my.queue(name)
if command == "Serve":
if my.is_empty():
print("the lineup is already empty")
else:
print("%s has beed served"%my.dequeue())
if command == "Exit":
import sys
sys.exit(0)
def hotpotato(namelist,num): q = Queue() for name in q: q.enqueue(name) while q.size() for i in range(num): q.enqueue(q.dequeue()) q.dequeue() return q.dequeue()
def hot_potato(name_list, num):
q = Queue()
for name in name_list:
q.enqueue(name)
while q.size() > 1 :
# print q
for i in range(num):
q.enqueue(q.dequeue())
print q
q.dequeue()
return q.dequeue()
def hotPotato(nameList,num): q = Queue() for name in nameList : q.enqueue(name) while q.size()>1 : for i in range(num): q.enqueue(q.dequeue()) q.dequeue() return q.dequeue()
def passparcel(names, n):
pass_queue = Queue()
for name in names:
pass_queue.enqueue(name)
while pass_queue.size() > 1:
for i in range(n):
pass_queue.enqueue(pass_queue.dequeue())
pass_queue.dequeue()
return pass_queue.dequeue()
def hot(names, n):
q = Queue()
for name in names:
q.enqueue(name)
while q.size() > 1:
for i in range(n):
q.enqueue(q.dequeue())
q.dequeue()
print q.items
return q.dequeue()
def hotPotato(namelist, num):
queue = Queue()
for name in namelist:
queue.enqueue(name)
while queue.size() > 1:
for i in range(num):
queue.enqueue(queue.dequeue())
queue.dequeue()
return queue.dequeue()
def breadth_first_traversal(self, start):
"""Perform a breadth first traversal on a graph starting at the given node"""
from queue import Queue
q = Queue()
q.enqueue(start)
visited = [start]
while q.size() > 0:
current = q.dequeue()
for neighbor in self.neighbors(current):
if neighbor not in visited:
q.enqueue(neighbor)
visited.append(neighbor)
return visited
def hot_potato(name_list):
a_queue = Queue()
for name in name_list:
a_queue.enqueue(name)
while a_queue.size() > 1:
num = random.randint(1, 7)
for i in range(num):
tem = a_queue.dequeue()
a_queue.enqueue(tem)
a_queue.dequeue()
return a_queue.dequeue()
