class TestArrayQueue(unittest.TestCase): def setUp(self): self.queue = ArrayQueue() def test_enqueue(self): self.queue.enqueue(1) self.queue.enqueue(2) self.queue.enqueue(3) self.assertEqual(self.queue.size, 3) def test_dequeue(self): self.queue.enqueue(1) self.queue.enqueue(2) self.assertEqual(self.queue.dequeue(), 1) def test_peek(self): self.queue.enqueue(1) self.assertEqual(self.queue.peek(), 1) def test_peek_when_stack_is_empty(self): with self.assertRaises(Exception): self.queue.peek() def test_is_empty_when_stack_is_empty(self): self.assertEqual(self.queue.is_empty(), True) def test_is_empty_when_stack_is_not_empty(self): self.queue.enqueue(1) self.assertEqual(self.queue.is_empty(), False) def test_show_all(self): self.queue.show_all()
def _traverse_level_order_iterative(self, start_node, visit): """Traverse this binary tree with iterative level-order traversal (BFS). Start at the given node and visit each node with the given function. TODO: Running time: on each node we perform 3 operations, assumming each operations on each node take O(1) it takes 3 * O(n) for the tree to be traversed TODO: Memory usage: O(2^h) would be the worst running time if we have two children for every parent, but that might not be the case. Considering that a parent might have one child O(n) would be a better estimate.""" # TODO: Create queue to store nodes not yet traversed in level-order q = ArrayQueue() # TODO: Enqueue given starting node q.enqueue(start_node) # TODO: Loop until queue is empty while q.length() != 0: # TODO: Dequeue node at front of queue q.front() node = q.dequeue() # TODO: Visit this node's data with given function visit(node.data) # TODO: Enqueue this node's left child, if it exists if node.left: q.enqueue(node.left) # TODO: Enqueue this node's right child, if it exists if node.right: q.enqueue(node.right)
class TestArrayQueue(unittest.TestCase): def setUp(self): self.queue = ArrayQueue() def test_enqueue(self): self.queue.enqueue(1) self.queue.enqueue(2) self.queue.enqueue(3) self.assertEqual(self.queue.size, 3) def test_dequeue(self): self.queue.enqueue(1) self.queue.enqueue(2) self.assertEqual(self.queue.dequeue(), 1) def test_peek(self): self.queue.enqueue(1) self.assertEqual(self.queue.peek(), 1) def test_peek_when_stack_is_empty(self): with self.assertRaises(Exception): self.queue.peek() def test_is_empty_when_stack_is_empty(self): self.assertEqual(self.queue.is_empty(), True) def test_is_empty_when_stack_is_not_empty(self): self.queue.enqueue(1) self.assertEqual(self.queue.is_empty(), False) def test_show_all(self): self.queue.show_all()
def breadthfirst(self): if not self.is_empty(): fringe = ArrayQueue() fringe.enqueue(self.root()) while not fringe.is_empty(): p = fringe.dequeue() yield p for child in self.children(p): fringe.enqueue(child)
def _traverse_level_order_iterative(self, start_node, visit): """Traverse this binary tree with iterative level-order traversal (BFS). Start at the given node and visit each node with the given function. TODO: Running time: ??? Why and under what conditions? TODO: Memory usage: ??? Why and under what conditions?""" # TODO: Create queue to store nodes not yet traversed in level-order queue = ArrayQueue() # TODO: Enqueue given starting node queue.enqueue(start_node) # TODO: Loop until queue is empty while queue.length() != 0: # TODO: Dequeue node at front of queue node = queue.front() queue.dequeue() # TODO: Visit this node's data with given function visit(node.data) # TODO: Enqueue this node's left child, if it exists if node.left is not None: queue.enqueue(node.left) # TODO: Enqueue this node's right child, if it exists if node.right is not None: queue.enqueue(node.right)
def hot_potato(name_list, num): """ Hot potato simulator. While simulating, the name of the players eliminated should also be printed (Note: you can print more information to see the game unfolding, for instance the list of players to whom the hot potato is passed at each step...) :param name_list: a list containing the name of the players, e.g. ["John", "James", "Alice"] :param num: the counting constant (i.e., the length of each round of the game) :return: the winner (that is, the last player standing after everybody else is eliminated) """ Q = ArrayQueue() for i in name_list: Q.enqueue(i) while Q.__len__() != 1: for k in range(num): dequed = Q.dequeue() Q.enqueue(dequed) removed = Q.dequeue() print(f'{removed} has been removed from the game!') winner = Q.first() return winner
def BFS(G, a): status={} for node in G.nodes(): status[node]='U' nodes=ArrayQueue() nodes.enqueue(a) status[a]='V' while nodes.is_empty()==False: pnode=nodes.dequeue() for node in G.neighbors(pnode): if status[node]=='U': nodes.enqueue(node) status[node]='V' status[pnode]='P' print(pnode) return
def _traverse_level_order_iterative(self, start_node, visit): """Traverse this binary tree with iterative level-order traversal (BFS). Start at the given node and visit each node with the given function. TODO: Running time: ??? Why and under what conditions? TODO: Memory usage: ??? Why and under what conditions?""" # TODO: Create queue to store nodes not yet traversed in level-order queue = ArrayQueue() # TODO: Enqueue given starting node queue.enqueue(start_node) #Loop while queue has nodes while queue.length() > 0: node = queue.dequeue() #dequeue the first node visit(node.data) #visit the dequeue node #enqueue the children of the node if node.left != None: queue.enqueue(node.left) if node.right != None: queue.enqueue(node.right)
def items_level_order(self): """Return a list of all items in this binary search tree found using level-order traversal""" # Create a queue to store nodes not yet traversed in level-order queue = ArrayQueue() # Create an items list items = list() # Enqueue the root node if this tree is not empty if self.is_empty() is False: queue.enqueue(self.root) # Loop until the queue is empty while queue.is_empty() is False: # Dequeue the node at the front of the queue node = queue.dequeue() # Add this node's data to the items list items.append(node.data) # Enqueue this node's left child if it exists if node.left is not None: queue.enqueue(node.left) # Enqueue this node's right child if it exists if node.right is not None: queue.enqueue(node.right) # Return the items list return items
class QueueTest(unittest.TestCase): def __init__(self, *args, **kwargs): super(QueueTest, self).__init__(*args, **kwargs) self.ll_queue = LinkedListQueue() self.arr_queue = ArrayQueue() def test_ll_queue_enqueue(self): self.ll_queue.enqueue(10) self.ll_queue.enqueue(20) self.ll_queue.enqueue(30) self.ll_queue.enqueue(40) self.assertEqual([i for i in self.ll_queue], [10, 20, 30, 40]) self.ll_queue.enqueue(50) self.assertEqual([i for i in self.ll_queue], [10, 20, 30, 40, 50]) def test_ll_queue_dequeue(self): self.ll_queue.enqueue(10) self.ll_queue.enqueue(20) self.ll_queue.enqueue(30) self.ll_queue.enqueue(40) self.assertEqual(self.ll_queue.dequeue(), 10) self.assertEqual([i for i in self.ll_queue], [20, 30, 40]) self.assertEqual(self.ll_queue.dequeue(), 20) self.assertEqual(self.ll_queue.dequeue(), 30) self.assertEqual(self.ll_queue.dequeue(), 40) self.assertRaises(IndexError, self.ll_queue.dequeue) self.ll_queue.enqueue(10) self.ll_queue.enqueue(20) self.assertEqual(self.ll_queue.dequeue(), 10) def test_arr_queue_enqueue(self): self.arr_queue.enqueue(10) self.arr_queue.enqueue(20) self.arr_queue.enqueue(30) self.arr_queue.enqueue(40) self.assertEqual([i for i in self.arr_queue], [10, 20, 30, 40]) self.arr_queue.enqueue(50) self.assertEqual([i for i in self.arr_queue], [10, 20, 30, 40, 50]) self.arr_queue.enqueue(60) self.arr_queue.enqueue(70) self.assertEqual([i for i in self.arr_queue], [10, 20, 30, 40, 50, 60, 70]) self.arr_queue.enqueue(80) self.arr_queue.enqueue(90) self.arr_queue.enqueue(100) self.arr_queue.enqueue(110) self.arr_queue.enqueue(120) self.arr_queue.enqueue(130) self.assertEqual( [i for i in self.arr_queue], [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130]) def test_arr_queue_dequeue(self): self.arr_queue.enqueue(10) self.arr_queue.enqueue(20) self.arr_queue.enqueue(30) self.arr_queue.enqueue(40) self.assertEqual(self.arr_queue.dequeue(), 10) self.assertEqual([i for i in self.arr_queue], [20, 30, 40]) self.assertEqual(self.arr_queue.dequeue(), 20) self.assertEqual(self.arr_queue.dequeue(), 30) self.assertEqual(self.arr_queue.dequeue(), 40) self.assertRaises(IndexError, self.arr_queue.dequeue) self.arr_queue.enqueue(10) self.arr_queue.enqueue(20) self.assertEqual(self.arr_queue.dequeue(), 10) self.arr_queue.enqueue(30) self.arr_queue.enqueue(40) self.assertEqual([i for i in self.arr_queue], [20, 30, 40])
from queue import ArrayQueue q = ArrayQueue() data_entry = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] for data in data_entry: q.enqueue(data) # test to see if the length of the data array is double print(len(q.data)) data_recptr = [] for n in range(9): data_recptr.append(q.dequeue()) print(data_recptr) # the size of the queue shrinks to less than 1/4, # accordingly, the size of the array shrinks to half print(len(q.data))