class QStack: def __init__(self): self.data = ArrayQueue() def __len__(self): return len(self.data) def is_empty(self): return len(self) == 0 def push(self, elem): #O(1) self.data.enqueue(elem) def pop(self): #O(n) if self.is_empty(): raise Exception("The QStack is empty") helper = ArrayQueue() for i in range(len(self) - 1): helper.enqueue(self.data.dequeue()) val = self.data.dequeue() self.data = helper return val def top(self): #O(n) if self.is_empty(): raise Exception("The QStack is empty") helper = ArrayQueue() for i in range(len(self)): val = self.data.dequeue() helper.enqueue(val) self.data = helper return val
def breadth_first_print(self): Q = ArrayQueue() Q.enqueue(self.root()) while not Q.is_empty(): p = Q.dequeue() print(p) for c in self.children(p): Q.enqueue(c)
def breath_first(self): from ArrayQueue import ArrayQueue fringe = ArrayQueue() fringe.enqueue(self.root()) while not fringe.is_empty(): p = fringe.dequeue() yield p for c in p.children(): fringe.enqueue(c)
def permutations(lst): stack = ArrayStack() queue = ArrayQueue() for val in lst: queue.enqueue([val]) while (len(lst) != len(queue.first())): for integer in lst: if integer not in queue.first(): stack.push([integer]) for i in range(len(stack)): queue.enqueue(queue.first() + stack.pop()) queue.dequeue() while queue.is_empty == False: permuations_array.append(q.dequeue()) return permuations_array
def n_bonacci(n, k): numQueue = ArrayQueue() numOfVals = 0 for i in range(n): if numOfVals == k: return numQueue.enqueue(1) numOfVals += 1 yield 1 while numOfVals < k: nextVal = 0 for i in range(len(numQueue)): nextVal += numQueue.first() numQueue.enqueue(numQueue.dequeue()) numQueue.dequeue() numQueue.enqueue(nextVal) yield nextVal numOfVals += 1
def print_tree(self): q = ArrayQueue() q.enqueue(self.root) while not q.empty(): n = q.dequeue() print('[k: ' + str(n.key) + ', v: ' + str(n.value) + ']') if n.left is not None: q.enqueue(n.left) if n.right is not None: q.enqueue(n.right)
def breadth_first(self): if (self.is_empty()): return line = ArrayQueue() line.enqueue(self.root) while (line.is_empty() == False): curr_node = line.dequeue() yield curr_node if (curr_node.left is not None): line.enqueue(curr_node.left) if (curr_node.right is not None): line.enqueue(curr_node.right)
def invert_binary_tree2(root): if (root is None): return line = ArrayQueue() line.enqueue(root) while (line.is_empty() == False): curr_node = line.dequeue() curr_node.left, curr_node.right \ = curr_node.right, curr_node.left if (curr_node.left is not None): line.enqueue(curr_node.left) if (curr_node.right is not None): line.enqueue(curr_node.right)
class Company: def __init__(self): self._actions = ArrayQueue() def buy(self, quantity, price): self._actions.enqueue(Sale(quantity, price)) def sell(self, quantity, price): gain = 0 while quantity > 0: latest = self._actions.first() if latest.qua <= quantity: gain += latest.qua * (price - latest.price) quantity -= latest.qua self._actions.dequeue() else: gain += quantity * (price - latest.price) latest.qua -= quantity quantity = 0 return gain def __str__(self): return str(self._actions._data)
def __str__(self): str_return = '' q_uttt = ArrayQueue() q_uttt.enqueue(self._root) last_depth = 0 while not q_uttt.is_empty(): child = q_uttt.dequeue() if last_depth != child.get_depth(): str_return += "\n" str_return += child.get_meta().get_meta_int() + ' ' last_depth = child.get_depth() for grand_child in child.get_children(): q_uttt.enqueue(grand_child) return str_return
class MeanQueue: def __init__(self): self.data = ArrayQueue() def __len__(self): return len(self.data) def is_empty(self): return len(self.data) == 0 def enqueue(self, e): if not isinstance(e, (int, float)): raise TypeError("Item must be int or float type!") self.data.enqueue(e) def dequeue(self): if self.is_empty(): raise Exception("MeanQueue is empty!") return self.data.dequeue() def first(self): if self.is_empty(): raise Exception("MeanQueue is empty!") return self.data.first() def sum(self): total = 0 for i in range(len(self)): total += self.data.first() self.data.enqueue(self.data.dequeue()) return total def mean(self): return self.sum() / len(self)
class QueueStack: def __init__(self): self.data = ArrayQueue() def __len__(self): return len(self.data) def is_empty(self): return len(self) == 0 def push(self, e): self.data.enqueue(e) def pop(self): for i in range(len(self) - 1): self.data.enqueue(self.data.dequeue()) return self.data.dequeue() def top(self): for i in range(len(self) - 1): self.data.enqueue(self.data.dequeue()) val = self.data.first() self.data.enqueue(self.data.dequeue()) return val
def permutations(lst): perms = ArrayStack() parts = ArrayQueue() combo = [] for x in range(len(lst)): if perms.is_empty(): perms.push([lst[x]]) else: for y in range(len(perms)): p_lst = perms.pop() for z in range(len(p_lst) + 1): parts.enqueue(p_lst[:z] + [lst[x]] + p_lst[z:]) for a in range(len(parts)): perms.push(parts.dequeue()) while not perms.is_empty(): combo.append(perms.pop()) return combo
class CheckoutManager(object): """CheckoutManager object for handling a collection of checkout queues that process customers.'""" def __init__(self, n_checkouts, checkout_capacity, staging_capacity): self.checkouts = [ArrayQueue(checkout_capacity) for _ in xrange(n_checkouts)] self.staging_queue = ArrayQueue(staging_capacity) self.finished_customers = [] def enqueue_random(self, customer): """Adds the given customer to a random checkout.""" checkout = random.choice(self.checkouts) customer.queue(checkout) def enqueue_shortest(self, customer): """Adds the given customer to the checkout with the shortest queue.""" checkout = min(self.checkouts, key=len) customer.queue(checkout) def enqueue_staging(self, customer): """Adds the customer to a staging queue. The customer will move from the staging queue to an empty checkout as one becomes available.""" customer.queue(self.staging_queue) def has_item(self): """Checks if any checkout has a customer in it, or if the staging queue has a customer in it.""" for checkout in self.checkouts: if checkout.has_item(): return True return False def update(self): """Called once per game cycle.""" for checkout in self.checkouts: if checkout.has_item(): if checkout[0].checked_out(): # remove finished customer customer = checkout.dequeue() customer.leave() if checkout.empty() and self.staging_queue.has_item(): # add waiting customer customer = self.staging_queue.dequeue() customer.queue(checkout) if checkout.has_item(): checkout[0].checkout() # checkout front customer
def is_complete(root): if (root is None): return True line = ArrayQueue() line.enqueue(root) level = 0 while (line.is_empty() == False): if (len(line) != 2**level): return False for i in range(2**level): curr_node = line.dequeue() if (curr_node.left is not None): line.enqueue(curr_node.left) if (curr_node.right is not None): line.enqueue(curr_node.right) level += 1 return True
def print_tree_level(bin_Tree, level): output = [] if (bin_Tree.is_empty()): return line = ArrayQueue() line.enqueue((bin_Tree.root, 0)) while (line.is_empty() == False): curr = line.dequeue() output.append(curr) depth = curr[1] if (curr[0].left is not None): line.enqueue((curr[0].left, depth + 1)) if (curr[0].right is not None): line.enqueue((curr[0].right, depth + 1)) i = 0 outputlst = [] for i in output: if i[1] == level: outputlst.append(i[0].data) print(outputlst)
if __name__ == '__main__': q = ArrayQueue() print("Is queue empty: ") if q.empty(): print("yes") else: print("no") print("Enqueueing 9...") q.enqueue(9) print("Is queue empty: ") if q.empty(): print("yes") else: print("no") print("Dequeueing... ") print(q.dequeue()) print("Enqueueing 45, 53, and 85...") q.enqueue(45) q.enqueue(53) q.enqueue(85) print("Now dequeueing all of them...") print(q.dequeue()) print(q.dequeue()) print(q.dequeue()) print("Is queue empty: ") if q.empty(): print("yes") else: print("no")
""" 3 Suppose you have a deque D containing the numbers (1,2,3,4,5,6,7,8), in this order. Suppose further that you have an initially empty queue Q. Give a code fragment that uses only D and Q (and no other variables) and results in D storing the elements in the order (1,2,3,5,4,6,7,8).\ """ from collections import deque from ArrayQueue import ArrayQueue d = deque(list(range(10))) q = ArrayQueue() for _ in range(len(d)): q.enqueue(d.pop()) for _ in range(len(q)): d.append(q.dequeue()) print(d)
if __name__ == "__main__": D = ArrayDeque() Q = ArrayQueue() for i in range(1, 9): D.add_last(i) # step 1 for _ in range(3): Q.enqueue(D.delete_last()) # step 2 for _ in range(2): D.add_first(D.delete_last()) # step 3 for _ in range(3): Q.enqueue(D.delete_last()) # step 4 D.add_first(D.delete_last()) # step 5 for _ in range(3): D.add_first(Q.dequeue()) # step 6 for _ in range(3): D.add_last(D.delete_first()) # step 7 for _ in range(3): D.add_first(Q.dequeue()) # check result for i in range(8): print(D.delete_first())
block_lst = [] job_is_running_time = 0 # to calc cpu utilization job_is_blocking_time = 0 # to calc i/o utilization if detailed_mode: print( "\nThis detailed printout gives the state and remaining burst for each process.\n" ) while job_incomplete > 0: # one time unit is one cycle if detailed_mode: cycle_report(time, jobs_lst) # scan status for change scan_job(Q, jobs_lst, time) if not Q.is_empty() and cpu_can_run: cur_job = Q.dequeue() cur_job.start_run() job_running_in_cur_cycle = False job_is_blocking_in_cur_cycle = False for j in jobs_lst: if j.get_state() == 'running': j.run_controller() job_running_in_cur_cycle = True elif j.get_state() == 'blocked': j.block_controller() job_is_blocking_in_cur_cycle = True elif j.get_state() == 'ready': j.increment_waiting_time() if job_running_in_cur_cycle:
class TestArrayQueue(unittest.TestCase): def setUp(self): self.q = ArrayQueue() self.q.enqueue(1) self.q.enqueue(2) self.q.enqueue(3) def test_instantiation(self): print('Can create an instance') self.assertIsInstance(self.q, ArrayQueue) def test_length_checking(self): print('Can check the length of the queue') self.assertEqual(len(self.q), 3) def test_first_method(self): print('Can return the first element of the queue') self.assertEqual(self.q.first(), 1) def test_enqueue_method(self): print('Can add elements to the queue') self.q.enqueue(4) self.q.enqueue(5) self.assertEqual(len(self.q), 5) self.assertEqual(self.q.first(), 1) def test_dequeue_method(self): print('Can remove elements from the front of the queue') self.q.enqueue(4) self.q.enqueue(5) self.q.dequeue() self.assertEqual(self.q.dequeue(), 2) self.assertEqual(len(self.q), 3) self.assertEqual(self.q.first(), 3) def test_is_empty_method(self): print('Can check if the queue is empty') self.q.dequeue() self.q.dequeue() self.q.dequeue() self.assertEqual(self.q.is_empty(), True) def test_exception_raising(self): print( 'Can raise exception while performing action(s) on an empty queue') self.q.dequeue() self.q.dequeue() self.q.dequeue() with self.assertRaises(Empty): self.q.first() self.q.dequeue()