class TestQueue(unittest.TestCase): def setUp(self): self.queue = Queue() def tearDown(self): return super().tearDown() def test_size(self): self.assertEqual(self.queue.size(), 0) def test_enqueue(self): self.queue.enqueue(1) self.assertEqual(self.queue.size(), 1) def test_dequeue(self): self.queue.enqueue(1) self.assertEqual(self.queue.dequeue(), 1) self.assertEqual(self.queue.size(), 0) def test_front(self): self.queue.enqueue(1) self.assertEqual(self.queue.front(), 1) def test_dequeue_exception(self): self.assertIsNone(self.queue.dequeue()) def test_front_exception(self): self.assertIsNone(self.queue.front())
def test_peak(self): queue = Queue() queue.enqueue(1) self.assertEqual(queue.peek(), 1) queue.enqueue(2) self.assertEqual(queue.peek(), 1) queue.enqueue(13) self.assertEqual(queue.peek(), 1) queue.dequeue() self.assertEqual(queue.peek(), 2)
def test_queue(self): q = Queue(1) q.enqueue(2) q.enqueue(3) assert q.peek() == 1 assert q.dequeue() == 1 q.enqueue(4) assert q.dequeue() == 2 assert q.dequeue() == 3 assert q.dequeue() == 4 q.enqueue(5) assert q.peek() == 5
def bfs(start): start.setDistance(0) start.setPred(None) # Queue for hold vertexes. vertQueue = Queue() vertQueue.enqueue(start) while vertQueue.size() > 0: # Get first value from queue. curVertex = vertQueue.dequeue() # Go through all the neigbors of the current vertex. for nbr in curVertex.getConnections(): # Check if the neighbor was not achieved. if nbr.getColor() == 'white': # Mark neighbor as achieved. nbr.setColor('grey') # Compute distance between current vertex and neighbor. nbr.setDistance(curVertex.getDistance() + 1) # Set predecessor as a current vertex for, # for afterwards recreate the path. nbr.setPred(curVertex) # Add neighbor to end of queue. vertQueue.enqueue(nbr) # Mark current vertex as passed. curVertex.setColor('black')
def test_enqueue_five_elements_to_queue_and_dequeue_all_elements(self): queue = Queue() langs = ['python', 'java', 'ruby', 'php', 'go'] for lang in langs: queue.enqueue(lang) self.assertEqual(len(langs), queue.size()) element1 = queue.dequeue() element2 = queue.dequeue() element3 = queue.dequeue() element4 = queue.dequeue() element5 = queue.dequeue() self.assertEqual('python', element1) self.assertEqual('java', element2) self.assertEqual('ruby', element3) self.assertEqual('php', element4) self.assertEqual('go', element5) self.assertTrue(queue.is_empty())
def bfs(g, start): start.set_distance(0) start.set_pred(None) vert_queue = Queue() vert_queue.enqueue(start) while vert_queue.size() > 0: current_vert = vert_queue.dequeue()
def test_dequeue(self): queue = Queue() queue.enqueue(1) queue.enqueue(2) queue.enqueue(13) queue.enqueue(31) # assert that the item dequeued was the item at the head self.assertEqual(queue.dequeue(), 1) # assert that the item at the head of the linked list was removed self.assertEqual(queue.items.walk(), [2, 13, 31])
def test_enqueue_five_elements_to_queue_and_dequeue_two_elements(self): queue = Queue() langs = ['python', 'java', 'ruby', 'php', 'go'] for lang in langs: queue.enqueue(lang) self.assertEqual(len(langs), queue.size()) element1 = queue.dequeue() element2 = queue.dequeue() self.assertEqual('python', element1) self.assertEqual('java', element2) self.assertEqual(3, queue.size())
def breadth_first(self): visited = Queue() visited.enqueue(self) while visited: try: node = visited.dequeue() except LookupError: return if node.left: visited.enqueue(node.left) if node.right: visited.enqueue(node.right) yield node
class StackUsingQueue(object): def __init__(self): self._queue_one = Queue() self._queue_two = Queue() def __str__(self): return self._queue_one.__str__() def push(self, element): ''' :param element: element to be pushed onto stack ''' while not self._queue_one.is_empty(): self._queue_two.enqueue(self._queue_one.dequeue()) self._queue_one.enqueue(element) while not self._queue_two.is_empty(): self._queue_one.enqueue(self._queue_two.dequeue()) return def pop(self): return self._queue_one.dequeue()
def _get_node(self, element): queue = Queue() queue.enqueue(self.root) while queue: current = queue.dequeue() if current.element == element: return current children = current.get_children() if children: for child in children: queue.enqueue(child) return None
def bfs(self, current): # Implementation: Iterative 1 if current is None: return queue = Queue() queue.enqueue(current) while current is not None: current = current.next_sibling if queue and current is None: current = queue.dequeue().first_child if current and current.first_child: queue.enqueue(current)
def level_order_traverse(root): if root is None: return queue = Queue() queue.enqueue(root) while not queue.is_empty(): node = queue.dequeue() print node, if node.lchild is not None: queue.enqueue(node.lchild) if node.rchild is not None: queue.enqueue(node.rchild) print
def move(self, element, parent): moving_node = self._get_node(element) destination_node = self._get_node(parent) if not moving_node: raise ElementNotFoundError( "Could not find element {}".format(element)) if not destination_node: raise ElementNotFoundError( "Could not find parent {}".format(parent)) if moving_node == self.root: raise MovingRootError("Cannot move root node.") parent_node = None previous_sibling_node = None queue = Queue() queue.enqueue(self.root) while queue: current = queue.dequeue() if current.first_child == moving_node: parent_node = current if current.next_sibling == moving_node: previous_sibling_node = current if current == moving_node: break children = current.get_children() if children: for child in children: queue.enqueue(child) if parent_node: parent_node.first_child = moving_node.next_sibling if previous_sibling_node: previous_sibling_node.next_sibling = moving_node.next_sibling next_sibling_node = destination_node.first_child destination_node.first_child = moving_node moving_node.next_sibling = next_sibling_node
def bft_print_tree(self): """breadth first traversal method to print a tree """ if self is None: return None # make a queue, add thehfirst node current = self lst = Queue() lst.enqueue(current.value) # while queue is not empty while len(lst) > 0: # remove the current, and print it print(lst.dequeue()) # add all children of the current if current.left: current = current.left lst.enqueue(current.value) if current.right: current = current.right lst.enqueue(current.value)