def bf_traverse(self): q = ArrayQueue() if self.r != self.nil: q.add(self.r) while q.size() > 0: u = q.remove() if u.left != self.nil: q.add(u.left) if u.right != self.nil: q.add(u.right)
def test_ArrayQueue_dequeue(self): queue = ArrayQueue() 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 stack_to_queue(stack): """ Converts the stack to a queue. """ q = ArrayQueue() for i in list(stack)[::-1]: q.add(i) return q
def stack_to_queue(stack): """ Convert stack to queue """ queue = ArrayQueue() while len(stack) != 0: num = stack.pop() queue.add(num) return queue
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 = ArrayQueue()
def stackToQueue(stack): stack_copy = copy.deepcopy(stack) queue = ArrayQueue() while True: try: queue.add(stack_copy.pop()) except KeyError: break return queue
def stack_to_queue(stack): ''' Conver stack to queue. ''' stack_copy = deepcopy(stack) queue = ArrayQueue() while stack_copy: queue.add(stack_copy.pop()) return queue
def stack_to_queue(stack): """Converts stack to a queue""" start_stack = copy.deepcopy(stack) output_queue = ArrayQueue() while start_stack.isEmpty() is False: elem = start_stack.pop() output_queue.add(elem) return output_queue
def queue_to_stack(queue): '''Convert queue to stack, without modifying the queue peek of the stack must be first element of the queue''' stack = ArrayStack() queue_copy = ArrayQueue(queue) while len(queue_copy) != 0: stack.push(queue_copy.remove(len(queue_copy) - 1)) return stack
def stack_to_queue(stack): '''Convert stack to queue, without changing given stack peek of the stack is the first element in the queue''' queue = ArrayQueue() stack_copy = ArrayStack(stack) while len(stack_copy) != 0: queue.add(stack_copy.pop()) return queue
def stack_to_queue(stack): copied = copy(stack) # print(copied) the_queue = ArrayQueue() future_queue = [] while True: try: future_queue.append(copied.pop()) except KeyError: return ArrayQueue(future_queue)
def stack_to_queue(stack: ArrayStack) -> ArrayQueue: """ Converts stack to queue and returns Queue object """ queue = ArrayQueue() copy_of_stack = deepcopy(stack) while not copy_of_stack.isEmpty(): queue.add(copy_of_stack.pop()) return queue
def stack_to_queue(stack): """ Converts stack to queue. """ list_stack = [] for i in stack: list_stack.append(i) list_queue = list_stack[::-1] new_queue = ArrayQueue() for j in range(len(list_stack)): new_queue.add(list_queue[j]) return new_queue
def test_ArrayQueue_multipleoperations(self): queue = ArrayQueue() for i in range(100): queue.enqueue(i + 100) for i in range(50): queue.dequeue() for i in range(100): queue.enqueue(i + 200) assert_equal(150, queue.front())
def stack_to_queue(stack): """ Converts stack to queue. """ temp_stack = ArrayStack() result_queue = ArrayQueue() while not stack.isEmpty(): elem = stack.pop() result_queue.add(elem) temp_stack.push(elem) while not temp_stack.isEmpty(): stack.push(temp_stack.pop()) return result_queue
def stack_to_queue(stack): """ Return queue from stack (front of queue is peek of stack). """ copy_stack = ArrayStack() queue = ArrayQueue() for element in stack: copy_stack.push(element) while len(copy_stack) != 0: queue.add(copy_stack.pop()) 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 = ArrayQueue() 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 __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 = ArrayQueue() 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 queue_to_stack(queue: ArrayQueue) -> ArrayStack: """ Return stack from queue (front of queue is peek of stack). """ copy_queue = ArrayQueue() stack = ArrayStack() for element in queue: copy_queue.add(element) reversed_queue = reverse_queue(copy_queue) for element in reversed_queue: stack.push(element) return stack
def test_ArrayQueue_front(self): queue = ArrayQueue() for i in range(100): queue.enqueue(i + 1) for i in range(100): assert_equal(i + 1, queue.front()) queue.dequeue()
def test(): Q = ArrayQueue() Q.enqueue(5) Q.enqueue(3) print(Q.data) print(Q.dequeue()) print(Q.is_empty()) print(Q.first()) print(Q.data)
def queue_to_stack(queue): """ converts queue to a stack """ queue_copy = ArrayQueue(queue) stack = ArrayStack() while True: try: element = queue_copy.pop() stack.push(element) except KeyError: break stack_reversed = ArrayStack() while True: try: element = stack.pop() stack_reversed.push(element) except KeyError: break return stack_reversed
def queue_to_stack(queue): """ Converts the queue to a stack. """ stk_ar = ArrayStack() q = ArrayQueue(queue) el = [] while not q.isEmpty(): el.append(q.pop()) q1 = ArrayQueue(el[::-1]) while not q1.isEmpty(): stk_ar.push(q1.pop()) return stk_ar
def breadthfirst(self): """ Breadth first iteration of all tree positions """ if not self.is_empty(): fringe = ArrayQueue() fringe.enqueue(self.root()) while not fringe.is_empty(): p = fringe.dequeue() yield p for c in self.children(p): fringe.enqueue(c)
def reverse_queue(queue: ArrayQueue) -> ArrayQueue: """ Return reversed queue. (Destructive! Clear queue). """ if len(queue) <= 1: return queue element = queue.pop() reversed_queue = reverse_queue(queue) reversed_queue.add(element) return reversed_queue
def stack_to_queue(stack): """ converts stack to queue """ stack_copy = ArrayStack(stack) queue = ArrayQueue() while True: try: element = stack_copy.pop() queue.add(element) except KeyError: break queue_reversed = ArrayQueue() while True: try: element = queue.pop() queue_reversed.add(element) except KeyError: break return queue_reversed
def breadth_first_search(self, v, reach, label): aq = ArrayQueue() reach[v] = label aq.put(v) while not aq.is_empty(): w = aq.remove() p = self.adj_list[w].first_node while p: u = p.element.v if not reach[u]: aq.put(u) reach[u] = label p = p.next print(reach)
def level_order(self, visit): linked_binary_tree.visit = visit aq = ArrayQueue() curr_node = self.root while curr_node: visit(curr_node) if curr_node.lc: aq.put(curr_node.lc) if curr_node.rc: aq.put(curr_node.rc) curr_node = aq.remove()
def main(): """ tests module. """ queue = ArrayQueue() for i in range(10): queue.add(i) stack = queue_to_stack(queue) assert str(queue) == "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]" assert str(stack) == "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]" assert stack.pop() == 0 assert queue.pop() == 0 stack.add(11) queue.add(11) assert str(queue) == '[1, 2, 3, 4, 5, 6, 7, 8, 9, 11]' assert str(stack) == "[9, 8, 7, 6, 5, 4, 3, 2, 1, 11]" print("Success!")
def computeShortestPaths(self, srcIndex, use_heap): self.source = srcIndex nodes = self.network.getNodes() self.distances = {} self.previous_nodes = {} for i in nodes: self.distances[i.node_id] = math.inf self.previous_nodes[i] = None self.distances[self.source] = 0 t1 = time.time() if not use_heap: self.queue = ArrayQueue() self.queue.make_queue(list(self.distances.keys())) while self.queue.length > 0: node_id = self.queue.deletemin(self.distances) if node_id is not None: for edge in nodes[node_id].neighbors: # if current distance is greater than distance if we take another path if self.distances[edge.dest.node_id] > ( self.distances[node_id] + edge.length): self.distances[edge.dest.node_id] = self.distances[ node_id] + edge.length self.previous_nodes[nodes[ edge.dest.node_id]] = nodes[node_id] self.queue.decreasekey() else: self.queue = HeapQueue() self.queue.make_queue(list(self.distances.keys()), self.distances) while self.queue.length > 0: node_id = self.queue.deletemin(self.distances) if node_id is not None: for edge in nodes[node_id].neighbors: if self.distances[edge.dest.node_id] > ( self.distances[node_id] + edge.length): self.distances[edge.dest.node_id] = self.distances[ node_id] + edge.length self.previous_nodes[nodes[ edge.dest.node_id]] = nodes[node_id] self.queue.decreasekey(edge.dest.node_id, self.distances) t2 = time.time() return t2 - t1
def queue_to_stack(queue): """ Converts queue to stack. """ temp_queue = ArrayQueue() temp_stack = ArrayStack() #elements are in reversed order result_stack = ArrayStack() while not queue.isEmpty(): elem = queue.pop() temp_queue.add(elem) temp_stack.push(elem) while not temp_queue.isEmpty(): queue.add(temp_queue.pop()) while not temp_stack.isEmpty(): result_stack.push(temp_stack.pop()) #we reverse elements return result_stack
from arrayqueue import ArrayQueue from arraystack import ArrayStack import random def queue_to_stack(queue): """ Convert queue to stack """ stack1 = ArrayStack() stack2 = ArrayStack() while len(queue) != 0: num = queue.pop() stack1.push(num) while len(stack1) != 0: num = stack1.pop() stack2.push(num) return stack2 if __name__ == '__main__': queue = ArrayQueue() stack = ArrayStack() for i in range(random.randint(5, 10)): m = random.randint(0, 10) queue.add(m) stack.push(m) print('Stack: ', stack) print('Queue: ', queue_to_stack(queue))
def stack_to_queue(stack): queue = ArrayQueue() new_stack = copy.deepcopy(stack) while not new_stack.isEmpty(): queue.add(new_stack.pop()) return queue