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
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)
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
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
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 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)
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 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
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
class Solution_32(object):
def __init__(self):
self.queue = LinkedQueue()
def printfromtoptobottom(self, treeroot):
if treeroot is None:
return None
self.queue.add(treeroot)
ret = []
while not self.queue.isEmpty():
node = self.queue.pop()
ret.append(node.data_)
if node.left_:
self.queue.add(node.left_)
if node.right_:
self.queue.add(node.right_)
return ret
class Stack(object):
def __init__(self):
self.stack1 = LinkedQueue()
self.stack2 = LinkedQueue()
def isEmpty(self):
if self.__len__() == 0:
return True
else:
return False
def __len__(self):
if self.stack1.size_ == 0:
return self.stack2.size_
else:
return self.stack1.size_
def peek(self):
if self.isEmpty():
raise KeyError('The stack is empty.')
elif not self.stack1.isEmpty():
item = self.stack1.peek()
return item
else:
item = self.stack2.peek()
return item
def push(self, item):
if self.isEmpty() or (not self.stack1.isEmpty()
and self.stack2.isEmpty()):
self.stack1.add(item)
else:
self.stack2.add(item)
def pop(self):
if self.isEmpty():
raise KeyError('The stack is empty.')
if not self.stack1.isEmpty():
while self.stack1.front_.next is not None:
self.stack2.add(self.stack1.pop())
item = self.stack1.pop()
return item
else:
while self.stack2.front_.next is not None:
self.stack1.add(self.stack2.pop())
item = self.stack2.pop()
return item
# def __iter__(self):
# def travser_stack_recursive(sta, templist):
# if sta.front_.next is not None:
# templist = travser_stack_recursive(sta.front_.next, templist)
# templist.append(sta.front_.data)
# return templist
#
# templist = list()
# if self.isEmpty():
# raise KeyError('The stack is empty.')
#
# if not self.stack1.isEmpty():
# travser_stack_recursive(self.stack1, templist)
# return iter(templist)
# else:
# travser_stack_recursive(self.stack2, templist)
# return iter(templist)
def __iter__(self):
if self.isEmpty():
raise KeyError('The stack is empty.')
templist = list()
if not self.stack1.isEmpty():
tempstack = copy.copy(self.stack1)
while tempstack.front_.next is not None:
templist.append(tempstack.pop())
templist.append(tempstack.pop())
templist.reverse() # ******
return iter(templist)
else:
tempstack = copy.copy(self.stack2)
while tempstack.front_.next is not None:
templist.append(tempstack.pop())
templist.append(tempstack.pop()).reverse()
templist.reverse() # ******
return iter(templist)