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 test_ArrayQueue(): s = ArrayQueue() print(s.empty()) for i in range(33): s.enqueue(i) print('loop', i) print(s.front()) s.print()
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 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 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)
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()
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 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 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
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)
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)
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 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 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 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)
#!/usr/local/bin/python3 """ # Tests for queue implementation using an underlying fixed-size array """ from ArrayQueue import ArrayQueue 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())
""" 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)
import sys sys.path.append( "/Users/liangy/data-structure-algorithms-python/Stacks-queues-Deques") from ArrayQueue import ArrayQueue, Empty from ArrayDeque import ArrayDeque 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