def stack_to_queue(my_stack):
s = deepcopy(my_stack)
q = LinkedQueue()
while not s.isEmpty():
q.add(s.peek())
s.pop()
return q
class Solution_32b(object):
def __init__(self):
self.queue = LinkedQueue()
def print_tree(self, treeroot):
if treeroot is None:
return
self.queue.add(treeroot)
nextlevel, tobeprinted = 0, 1
print('Print the tree structure by level.')
while not self.queue.isEmpty():
pnode = self.queue.peek()
print('%d' % pnode.data_, end=' | ')
if pnode.left_ is not None:
self.queue.add(pnode.left_)
nextlevel += 1
if pnode.right_ is not None:
self.queue.add(pnode.right_)
nextlevel += 1
self.queue.pop()
tobeprinted -= 1
if tobeprinted == 0:
print('\n')
tobeprinted = nextlevel
nextlevel = 0
def __init__(self, numOfPlayers=2):
self._numOfPlayers = numOfPlayers
self._totalScore = 0
self._deck = Deck()
self._queue = LinkedQueue()
for player in range(self._numOfPlayers):
self._queue.add(Player('Player ' + str(player + 1)))
self._currentPlayer = self._queue.pop()
def __init__(self):
"""
"""
self._totalCustomerWaitTime = 0
self._customersServed = 0
self._currentCustomer = None
self._queue = LinkedQueue()
def test_linkedqueue_dequeue(self):
queue = LinkedQueue()
for i in range(100):
queue.enqueue(i + 1)
for i in range(100):
assert_equal(i + 1, queue.dequeue())
assert_equal(99 - i, len(queue))
assert_equal(0, len(queue))
def __init__(self):
"""Maintains a queue of customers,
number of customers served, total customer wait time,
and a current customer being processed."""
self._totalCustomerWaitTime = 0
self._customersServed = 0
self._currentCustomer = None
self._queue = LinkedQueue()
def __init__(self, number):
"""Maintains a cashier number, a queue of customers,
number of customers served, total customer wait time,
and a current customer being processed."""
self.number = number
self.totalCustomerWaitTime = 0
self.customersServed = 0
self.currentCustomer = None
self.queue = LinkedQueue()
class TicketCounterSimulation:
# Create a simulation object.
def __init__(self, numAgents, numMinutes, betweenTime, serviceTime):
# Parameters supplied by the user.
self._arriveProb = 1.0 / betweenTime
self._serviceTime = serviceTime
self._numMinutes = numMinutes
# Simulation components.
self._passengerQ = Queue()
self._theAgents = Array(numAgents)
for i in range(numAgents):
self._theAgents[i] = TicketAgent(i + 1)
# Computed during the simulation.
self._totalWaitTime = 0
self._numPassengers = 0
# Run the simulation using the parameters supplied earlier.
def run(self):
for curTime in range(self._numMinutes + 1):
self._handleArrive(curTime)
self._handleBeginService(curTime)
self._handleEndService(curTime)
self.printResults()
# Print the simulation results.
def printResults(self):
numServed = self._numPassengers - len(self._passengerQ)
avgWait = float(self._totalWaitTime) / numServed
print("")
print("Number of passengers served = ", numServed)
print("Number of passengers remaining in line = %d" %
len(self._passengerQ))
print("The average wait time was %4.2f minutes." % avgWait)
# Handles simulation rule #1.
def _handleArrive(self, curTime):
if random.randint(0.0, 1.0) <= self._arriveProb:
self._numPassengers += 1
passenger = Passenger(self._numPassengers, curTime)
self._passengerQ.add(passenger)
# Handles simulation rule #2.
def _handleBeginService(self, curTime):
for agent in self._theAgents:
if agent.isFree():
if not self._passengerQ.isEmpty():
agent.startService(self._passengerQ.pop(),
curTime + self._serviceTime)
# Handles simulation rule #3.
def _handleEndService(self, curTime):
for agent in self._theAgents:
if agent.isFinished(curTime):
passenger = agent.stopService()
self._totalWaitTime += len(self._passengerQ)
def __init__(self, data1, data2, summary):
"""This method initializes."""
self.data1 = data1
self.data2 = data2
self.summary = summary
self.queue = LinkedQueue()
self.total_food = 0
self.total_transport = 0
self.extrainfo = ""
self.see = ""
def test_find_in_queue(self):
name = "Jose"
phone = "123-456-7890"
node = Node(name, phone)
queue = LinkedQueue()
queue.push(node)
self.assertEqual(queue.find(name), node)
def test_push_to_queue(self):
name = "Jose"
phone = "123-456-7890"
node = Node(name, phone)
queue = LinkedQueue()
queue.push(node)
self.assertEqual(len(queue), 1)
def stack_to_queue(stack):
"""Return a queue that contains items from the stack."""
queue = LinkedQueue()
item_list = []
for item in stack:
item_list.insert(0, item)
for item in item_list:
queue.add(item)
return queue
class Cashier(object):
"""Represents a cashier."""
def __init__(self, number):
"""Maintains a cashier number, a queue of customers,
number of customers served, total customer wait time,
and a current customer being processed."""
self._number = number
self._totalCustomerWaitTime = 0
self._customersServed = 0
self._currentCustomer = None
self._queue = LinkedQueue()
def getLineLength(self):
"""Returns the number of customers in the line."""
return len(self._queue)
def addCustomer(self, c):
"""Adds an arriving customer to my line."""
self._queue.add(c)
def serveCustomers(self, currentTime):
"""Serves my cuatomers during a given unit of time."""
if self._currentCustomer is None:
# No customers yet
if self._queue.isEmpty():
return
else:
# Pop first waiting customer and tally results
self._currentCustomer = self._queue.pop()
self._totalCustomerWaitTime += \
currentTime - \
self._currentCustomer.arrivalTime()
self._customersServed += 1
# Give a unit of service
self._currentCustomer.serve()
# If current customer is finished, send it away
if self._currentCustomer.amountOfServiceNeeded() == 0:
self._currentCustomer = None
def __str__(self):
"""Returns my results: my number, my total customers served,
my average wait time per customer, and customers left on my queue."""
if self._customersServed != 0:
aveWaitTime = float(self._totalCustomerWaitTime) /\
self._customersServed
else:
aveWaitTime = 0.0
result = "%4d %8d %13.2f %8d" % (self._number, self._customersServed,
aveWaitTime, len(self._queue))
return result
class Cashier(object):
"""Represents a cashier."""
def __init__(self):
"""Maintains a queue of customers,
number of customers served, total customer wait time,
and a current customer being processed."""
self._totalCustomerWaitTime = 0
self._customersServed = 0
self._currentCustomer = None
self._queue = LinkedQueue()
def addCustomer(self, c):
"""Adds an arriving customer to my line."""
self._queue.add(c)
def serveCustomers(self, currentTime):
"""Serves my cuatomers during a given unit of time."""
if self._currentCustomer is None:
# No customers yet
if self._queue.isEmpty():
return
else:
# Pop first waiting customer and tally results
self._currentCustomer = self._queue.pop()
self._totalCustomerWaitTime += \
currentTime - \
self._currentCustomer.arrivalTime()
self._customersServed += 1
# Give a unit of service
self._currentCustomer.serve()
# If current customer is finished, send it away
if self._currentCustomer.amountOfServiceNeeded() == 0:
self._currentCustomer = None
def __str__(self):
"""Returns my results: my total customers served,
my average wait time per customer, and customers left on my queue."""
result = "TOTALS FOR THE CASHIER\n" + \
"Number of customers served: " + \
str(self._customersServed) + "\n"
if self._customersServed != 0:
aveWaitTime = self._totalCustomerWaitTime /\
self._customersServed
result += "Number of customers left in queue: " + \
str(len(self._queue)) + "\n" + \
"Average time customers spend\n" + \
"waiting to be served: " + \
"%5.2f" % aveWaitTime
return result
def levelorder(self):
"""Supports a levelorder traversal on a view of self."""
lyst = list()
queue = LinkedQueue()
if not self.isEmpty():
queue.add(self.root)
while not queue.isEmpty():
node = queue.pop()
lyst.append(node.data)
if node.left != None:
queue.add(node.left)
if node.right != None:
queue.add(node.right)
return iter(lyst)
def add(self, item):
"""Adds item to its proper place in the queue."""
if self.isEmpty() or item >= self._rear.data:
LinkedQueue.add(self, item)
elif item < self._front.data:
self._front = Node(item, self._front)
self._size += 1
else:
probe = self._front
trailer = probe
while item >= data:
trailer = probe
probe = probe.next
trailer.next = Node(item, probe)
def add(self, item):
if self.isEmpty() or self._rear.data <= item:
LinkedQueue.add(item)
else:
probe = self._front
while probe.data <= item:
trailer = probe
probe = probe.next
newnode = Node(item, probe)
if probe == self._front:
self._front = newnode
else:
trailer.next = newnode
self._size += 1
def test_pop_from_queue(self):
name = "Jose"
phone = "123-456-7890"
node = Node(name, phone)
queue = LinkedQueue()
queue.push(node)
self.assertEqual(len(queue), 1)
popped = queue.pop()
self.assertEqual(popped, node)
self.assertEqual(len(queue), 0)
class Cashier(object):
def __init__(self):
self._total_customer_wait_time = 0
self._customers_served = 0
self._current_customer = None
self._queue = LinkedQueue()
def add_customer(self, c):
self._queue.add(c)
def serve_customers(self, current_time):
# 1. 当前顾客不存在,
if self._current_customer == None:
# 等待队列为空, 直接返回
if self._queue.isEmpty():
return
else: # 不为空, 将队头顾客提升为当前顾客
self._current_customer = self._queue.pop()
# 等待总时间加上当前顾客等待的时间
self._total_customer_wait_time += \
current_time - \
self._current_customer.arrival_time()
self._customers_served += 1
# 2. 给当前顾客一个单位服务
self._current_customer.serve()
# 如果当前顾客需要的单位服务已经满足, 则将当前顾客赋值为 None
if self._current_customer.amount_of_service_needed() == 0:
self._current_customer = None
def __str__(self):
"""
Returns my results: my total customers served,
my average wait time per customer, and customers left on my queue.
"""
result = "TOTALS FOR THE CASHIER\n" + \
"Number of customers served: " + \
str(self._customers_served) + "\n"
if self._customers_served != 0:
ave_wait_time = self._total_customer_wait_time /\
self._customers_served
result += "Number of customers left in queue: " + \
str(len(self._queue)) + "\n" + \
"Average time customers spend\n" + \
"waiting to be served: " + \
"%5.2f" % ave_wait_time
return result
def rebalance(self):
"""
Re balances the tree.
:return: rebalanced tree
"""
def tmp(qq, lst):
tmp_lst = [lst]
while True:
new_tmp_lst = []
for l in tmp_lst:
if not l:
tmp_lst.remove(l)
continue
qq.add(l[len(l) // 2])
new_tmp_lst.append(l[:len(l) // 2])
new_tmp_lst.append(l[len(l) // 2 + 1:])
if not tmp_lst:
break
tmp_lst = new_tmp_lst
res = [i for i in qq]
return res
res = [i for i in self.in_order()]
q = LinkedQueue()
tmp_list = (tmp(q, res))
self.clear()
for each in tmp_list:
self.add(each)
def add(self, item):
"""Adds item to its proper place in the queue."""
if self.isEmpty() or item >= self.rear.data:
LinkedQueue.add(self, item)
else:
probe = self.front
trailer = None
while item >= probe.data:
trailer = probe
probe = probe.next
newNode = Node(item, probe)
if trailer is None:
self.front = newNode
else:
trailer.next = newNode
self.size += 1
def add(self, item):
"""Adds item to its proper place in the queue."""
if self.isEmpty() or item >= self._rear.data:
LinkedQueue.add(self, item)
else:
probe = self._front
trailer = None
while item >= probe.data:
trailer = probe
probe = probe.next
newNode = Node(item, probe)
if trailer is None:
self._front = newNode
else:
trailer.next = newNode
self._size += 1
def levelorder(self):
"""Supports a levelorder traversal on a view of self."""
lyst = list()
queue = LinkedQueue()
def recurse():
if not queue.isEmpty():
node = queue.pop()
lyst.append(node.data)
if node.left != None:
queue.add(node.left)
if node.right != None:
queue.add(node.right)
recurse()
if not self.isEmpty():
queue.add(self._root)
recurse()
return iter(lyst)
def __init__(self):
"""Maintains a queue of customers,
number of customers served, total customer wait time,
and a current customer being processed."""
self._totalCustomerWaitTime = 0
self._customersServed = 0
self._currentCustomer = None
self._queue = LinkedQueue()
class Cashier(object):
def __init__(self):
"""
"""
self._totalCustomerWaitTime = 0
self._customersServed = 0
self._currentCustomer = None
self._queue = LinkedQueue()
def addCustomer(self, c):
self._queue.add(c)
def serveCustomers(self, currentTime):
"""
:param currentTime:
:type currentTime:
:return:
:rtype:
"""
if self._currentCustomer is None:
# No customers yet
if self._queue.isEmpty():
return
else:
# Pop first waiting customer and tally results
self._currentCustomer = self._queue.pop()
self._totalCustomerWaitTime += currentTime - self._currentCustomer.arrivalTime(
)
self._customersServed += 1
# Give a unit of service
self._currentCustomer.serve()
# If current customer is finished, send it away
if self._currentCustomer.amountOfServiceNeeded() == 0:
self._currentCustomer = None
def __str__(self):
result = "TOTALS FOR THE CASHIER\n" + "Number of customers served: " + \
str(self._customersServed) + "\n"
if self._customersServed != 0:
aveWaitTime = self._totalCustomerWaitTime / self._customersServed
result += "Number of customers left in queue: " \
+ str(len(self._queue)) + "\n" + "Average time customers spend\n" + \
"waiting to be served: " + "%5.2f" % aveWaitTime
return result
def test_linkedqueue_front(self):
queue = LinkedQueue()
for i in range(100):
queue.enqueue(i + 1)
for i in range(100):
assert_equal(i + 1, queue.front())
queue.dequeue()
def levelorder(self):
"""Supports a levelorder traversal on a view of self."""
our_list = []
our_queue = LinkedQueue()
def recurse():
if not our_queue.isEmpty():
node = our_queue.pop()
our_list.append(node.data)
if node.left is not None:
our_queue.add(node.left)
if node.right is not None:
our_queue.add(node.right)
recurse()
if not self.isEmpty():
our_queue.add(self._root)
recurse()
return iter(our_list)
def add(self, new_item):
"""重写超类的add方法"""
if self.isEmpty() or new_item >= self._rear.data:
# 添加到队尾
LinkedQueue.add(self, new_item)
else:
# 遍历队列, 根据优先级插入
probe = self._front
while new_item >= probe.data:
tailer = probe # 当前probe节点的上一个节点
probe = probe.next
new_node = Node(new_item, probe)
if probe == self._front:
# 只有一个节点
self._front = new_node
else:
# 多个节点
tailer.next = new_node
self._size += 1
def add(self, newItem):
"""Insert newItem after items of greater or equal priority or ahead of item of lesser
priority A has greater priority than B if A <B"""
if self.isEmpty() or newItem >= self._rear.data:
# New item goes at rear
LinkedQueue.add(self, newItem)
else:
# Search for a position where it's less
probe = self._front
while newItem >= probe.data:
trailer = probe
probe = probe.next
newNode = Node(newItem, probe)
if probe == self._front:
#new item does at front
self._front = newNode
else:
# New item goes between two nodes
trailer.next = newNode
self._size += 1
def add(self, new_item):
"""重写超类的add方法"""
# 在"急症室调度"示例中，data 是patient 对象
if self.isEmpty() or new_item._condition >= self._rear.data._condition:
# 添加到队尾
LinkedQueue.add(self, new_item)
else:
# 遍历队列, 根据优先级插入
probe = self._front
# 比较conditio 优先级
while new_item._condition >= probe.data._condition:
tailer = probe # 当前probe节点的上一个节点
probe = probe.next
new_node = Node(new_item, probe)
if probe == self._front:
# 只有一个节点
self._front = new_node
else:
# 多个节点
tailer.next = new_node
self._size += 1
def bfs(g, start):
start.setDistance(0)
start.setPred(None)
vertQueue = LinkedQueue()
vertQueue.add(start)
while not vertQueue.isEmpty():
currentVert = vertQueue.pop()
for nbr in currentVert.getConnections():
if (nbr.getColor()) == 'white':
nbr.setColor('gray')
nbr.setDistance(currentVert.getDistance() + 1)
nbr.setPred(currentVert)
vertQueue.add(nbr)
currentVert.setColor('black')
def breadthFirst(g, startLabel):
"""Returns a list of the vertex labels in the
order in which the vertices were visited."""
result = list()
g.clearVertexMarks()
queue = LinkedQueue()
queue.add(g.getVertex(startLabel))
while not queue.isEmpty():
vertex = queue.pop()
if not vertex.isMarked():
vertex.setMark()
result.append(vertex.getLabel())
for neighbor in g.neighboringVertices(vertex.getLabel()):
if not neighbor.isMarked():
queue.add(neighbor)
return result
def __init__(self, numAgents, numMinutes, betweenTime, serviceTime):
# Parameters supplied by the user.
self._arriveProb = 1.0 / betweenTime
self._serviceTime = serviceTime
self._numMinutes = numMinutes
# Simulation components.
self._passengerQ = Queue()
self._theAgents = Array(numAgents)
for i in range(numAgents):
self._theAgents[i] = TicketAgent(i + 1)
# Computed during the simulation.
self._totalWaitTime = 0
self._numPassengers = 0
def __init__(self, sourceCollection = None):
"""Sets the initial state of self, which includes the
contents of sourceCollection, if it's present."""
LinkedQueue.__init__(self, sourceCollection)