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 test_randomForFun(self): """random push/pops v.3, just making sure""" test = ArrayQueue() for i in range(1, 11): test.push(i) test.pop() test.pop() test.push('a') self.assertEqual(test.show_array, ['a', None, 3, 4, 5, 6, 7, 8, 9, 10])
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 test_random(self): """random push/pops""" test = ArrayQueue() for i in range(1, 11): test.push(i) for i in range(1, 11): test.pop() test.push('a') test.push('b') self.assertEqual(test.show_array, ['a', 'b', None, None, None, None, None, None, None, None])
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 test_clearPush(self): test = ArrayQueue() test.push(1) test.push(2) test.push(3) self.assertEqual(test.show_array, [1, 2, 3, None, None, None, None, None, None, None]) test.clear() self.assertEqual(test.show_array, [None, None, None, None, None, None, None, None, None, None]) test.push('a') test.push('b') test.pop() self.assertEqual(test.show_array, [None, 'b', None, None, None, None, None, None, None, None])
def test_popAll(self): """ pop all elements""" test = ArrayQueue() test.push(1) test.push(2) test.push(3) test.push(4) test.pop() test.pop() test.pop() test.pop() self.assertEqual(test.show_array, [None, None, None, None, None, None, None, None, None, None])
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)
def __init__(self): self._priority_queue = LinkedQueue() self._queue = ArrayQueue() self._current_plane = None self._total_plane_wait_time = 0 self._planes_served = 0 self._planes_crashed = 0 self._metrics = { "longest_wait_takeoff": 0, "longest_wait_landing": 0, "served_takeoff": 0, "served_landing": 0 }
def test_random2(self): """random push/pops v.2""" test = ArrayQueue() test.push(1) test.push(2) test.push(3) test.push(4) test.pop() test.pop() test.pop() test.push('a') test.push('b') self.assertEqual(test.show_array, [None, None, None, 4, 'a', 'b', None, None, None, None])
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
def bfs(self, r: int): seen = np.zeros(self.n, np.bool_) l = [] q = ArrayQueue() q.add(r) seen[r] = True while q.size() > 0: i = q.remove() l.append(i) ngh = self.out_edges(i) for k in range(0, ngh.size()): j = ngh.get(k) if seen[j] == False: q.add(j) seen[j] = True return l
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
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 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 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)
detailed_mode = False filepath = None if (len(sys.argv) == 3): if sys.argv[1] == '--verbose': detailed_mode = True filepath = sys.argv[2] elif (len(sys.argv) == 2): filepath = sys.argv[1] unsorted_jobs_lst = [] random_num_ind = 0 random_num_lst = loadRamdomNum() jobs_lst = read_jobs(filepath) Q = ArrayQueue() cpu_can_run = True job_incomplete = len(jobs_lst) time = 0 run_lst = [] 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)
def test_peek(self): test = ArrayQueue() test.push(1) self.assertEqual(test.peek(), 1)
def __init__(self): self.data = ArrayQueue() self.helpqueue = ArrayQueue()
def __init__(self): self.data = ArrayQueue()
def __init__(self): self._actions = ArrayQueue()
def test_initialize(self): """create an array w/ default size of 4""" test = ArrayQueue() self.assertEqual(test.show_array, [None, None, None, None, None, None, None, None, None, None])
def test_pushToCapacity(self): """ Fill entire array """ test = ArrayQueue() for i in range(1, 11): test.push(i) self.assertEqual(test.show_array, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
def setUp(self): self.queues = [] self.queues.append(LinkedQueue()) self.queues.append(ArrayQueue(0, 3)) self.queues.append(IntQueue(2))
def test_popEmpty(self): """Try pop on empty array""" test = ArrayQueue() test.pop() self.assertRaises(test.pop(), Exception)
def setUp(self): self.q = ArrayQueue() self.q.enqueue(1) self.q.enqueue(2) self.q.enqueue(3)
from ArrayQueue import ArrayQueue from LoopQueue import LoopQueue from time import time from random import randint def test_enqueue(queue, op_count): start_time = time() for i in range(op_count): queue.enqueue(randint(1, 2000)) return time() - start_time def test_dequeue(queue, op_count): start_time = time() for i in range(op_count): queue.dequeue() return time() - start_time op_count = 10000 array_queue = ArrayQueue() loop_queue = LoopQueue() print('ArrayQueue enqueue: ', test_enqueue(array_queue, op_count)) print('LoopQueue enqueue: ', test_enqueue(loop_queue, op_count)) print('ArrayQueue dequeue: ', test_dequeue(array_queue, op_count)) print('LoopQueue dequeue: ', test_dequeue(loop_queue, op_count))
def test_push(self): test = ArrayQueue() test.push(1) self.assertEqual(test.show_array, [1, None, None, None, None, None, None, None, None, None])