def test_enqueue(self):
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(13)
queue.enqueue(31)
self.assertEqual(queue.items.walk(), [1, 2, 13, 31])
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 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_enqueue_five_elements_and_iterate_queue(self):
queue = Queue()
langs = ['python', 'java', 'ruby', 'php', 'go']
for lang in langs:
queue.enqueue(lang)
self.assertEqual(len(langs), queue.size())
for element in queue:
self.assertIn(element, langs)
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 _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 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 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())
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 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
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
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 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)
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 test_enqueue_one_element_to_queue(self):
queue = Queue()
queue.enqueue('python')
self.assertEqual(1, queue.size())
