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)
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)