class AnimalShelter():
def __init__(self):
self.cat_queue = Queue()
self.dog_queue = Queue()
self.animals_served = 0
def enqueue(self, incoming_animal):
type_of_animal = type(incoming_animal)
# https://docs.python.org/3/library/functions.html#type
self.animals_served += 1
incoming_animal.animal_id = self.animals_served
if type_of_animal == Cat:
self.cat_queue.enqueue(incoming_animal)
elif type_of_animal == Dog:
self.dog_queue.enqueue(incoming_animal)
else:
raise InvalidOperationError("Sorry, we don't accept that type of animal here.")
def dequeue(self, request_type = None):
if request_type == "cat":
return self.cat_queue.dequeue()
elif request_type == "dog":
return self.dog_queue.dequeue()
elif request_type == None:
#which queue is older?
next_cat = self.cat_queue.peek().animal_id
next_dog = self.dog_queue.peek().animal_id
if next_cat < next_dog:
return self.cat_queue.dequeue()
else:
return self.dog_queue.dequeue()
else:
return None
def queue_vals():
queue = Queue()
queue.enqueue(8)
queue.enqueue('hi')
queue.enqueue(-4)
queue.enqueue(6)
return queue
def traverse_breadth_first(self):
q = Queue()
q.enqueue(self.root)
while q.peek():
curr = q.dequeue()
yield curr.value
if curr.l_child:
q.enqueue(curr.l_child)
if curr.r_child:
q.enqueue(curr.r_child)
def test_peek_post_dequeue():
q = Queue()
q.enqueue("apples")
q.enqueue("bananas")
q.dequeue()
actual = q.peek()
expected = "bananas"
assert actual == expected
def test_peek():
q = Queue()
q.enqueue("apple")
q.enqueue("banana")
q.enqueue("cucumber")
actual = q.peek()
expected = "apple"
assert actual == expected
def traverse_breath_first(self):
queue = Queue()
curr = self.root
queue.enqueue(curr)
# import pdb; pdb.set_trace()
while queue.is_empty():
curr = queue.dequeue()
if curr.child_left:
queue.enqueue(curr.child_left)
if curr.child_right:
queue.enqueue(curr.child_right)
yield (curr.value)
def test_queue_peek():
letters = Queue()
assert not letters.peek()
letters.enqueue('A')
assert letters.peek() == 'A'
letters.enqueue('B')
assert letters.peek() == 'A'
def breadth_first(self) -> list:
""" takes a Binary Tree as its unique input, traverse the input tree using a Breadth-first approach, and return a list of the values in the tree in the order they were encountered. """
frontier = Queue()
frontier.enqueue(self.root)
explored = []
current = None
while not frontier.is_empty():
current = frontier.dequeue()
explored.append(current.value)
if current.left:
frontier.enqueue(current.left)
if current.right:
frontier.enqueue(current.right)
return explored
def test_multiple_dequeue():
q = Queue()
q.enqueue('first value')
q.enqueue('second value')
q.dequeue()
q.dequeue()
assert q.front == None
def breadth_first(self, starting_node, action_function=None):
list_of_nodes = []
breadth_queue = Queue()
breadth_queue.enqueue(starting_node)
starting_node.visited = True
i = 1
while not breadth_queue.is_empty():
print(f"trip {i} through while loop")
i += 1
current_vertex = breadth_queue.dequeue()
list_of_nodes.append(current_vertex)
current_edges = self._adjacency_list[current_vertex]
for edge in current_edges:
if edge.vertex.visited == False:
breadth_queue.enqueue(edge.vertex)
edge.vertex.visited = True
# NOTE: Doing this traversal method over the weekend, I choose to give each Vertex an attribute of visited that had a value of True or False. During class on Monday, JB did say that some are set up this way. However, he said he prefers to keep track of the visited nodes by using a variable of type set. This prevents any possibility of leaving an item visited attribute as true. The set variable would be cleared to length 0 at the start of each breadth traversal.
for node in self._adjacency_list:
node.visted = False
list_of_values_of_nodes = list(map(lambda x: x.value, list_of_nodes))
# attempts to get the passed in function to act on the list_of_nodes and thereby append to the list existing in the space from where this method was called is on the next line.
# map(action_function(list_of_nodes))
# return list_of_nodes
return list_of_values_of_nodes
def queue_3vals():
queue = Queue()
queue.enqueue(3)
queue.enqueue(-8)
queue.enqueue('z')
queue.enqueue('a')
return queue
def breath_first(self):
rtn = []
queue = Queue()
curr = self.root
queue.enqueue(curr)
# import pdb; pdb.set_trace()
while queue.is_empty():
curr = queue.dequeue()
if curr.child_left:
queue.enqueue(curr.child_left)
if curr.child_right:
queue.enqueue(curr.child_right)
rtn.append(curr.value)
return rtn
def breadth_traverse(self):
""" Breadth-first traversal of binary tree """
output = []
q = Queue()
q.enqueue(self.root)
while q.peek():
curr = q.dequeue()
output.append(curr.value)
if curr.l_child:
q.enqueue(curr.l_child)
if curr.r_child:
q.enqueue(curr.r_child)
return output
def test_peek_queue():
q3 = Queue()
q3.enqueue(1)
q3.enqueue(3)
q3.enqueue(5)
q3.enqueue(7)
assert q3.peek() == 1
assert not q3.is_empty()
def find_max_value(self):
max_value = self.root.value
curr=self.root
queue=Queue()
queue.enqueue(curr)
# import pdb; pdb.set_trace()
while queue.is_empty():
curr = queue.dequeue()
if curr.value > max_value:
max_value=curr.value
if curr.child_left:
queue.enqueue(curr.child_left)
if curr.child_right:
queue.enqueue(curr.child_right)
return max_value
def test_enqueue_onto_full():
q = Queue()
q.enqueue("apple")
q.enqueue("banana")
q.enqueue("cucumber")
actual = q.front.value
expected = "apple"
assert actual == expected
def radix_sort(list):
queues = [Queue() for i in range(0, 10)]
new_max = max(list) if len(list) > 0 else 0
iter = len(str(new_max))
_pass = 0
def _radix_sort(list):
"""
Radix sort helper method
"""
nonlocal iter
nonlocal _pass
while _pass < iter:
output = []
for j in list:
q = j // (10**_pass) % 10
queues[q].enqueue(j)
for q in queues:
while q.front:
output.append(q.dequeue())
_pass += 1
return _radix_sort(output)
return list
return _radix_sort(list)
def test_stacks_and_queues_10 ():
queue = Queue()
queue.enquene('a')
queue.enquene('b')
queue.enquene('c')
queue.dequeue()
actual = queue.front.value
expected = 'b'
assert actual == expected
def test_dequeue():
letters = Queue()
letters.enqueue('A')
letters.enqueue('B')
letters.enqueue('C')
assert letters.dequeue() == 'A'
assert letters.dequeue() == 'B'
assert letters.dequeue() == 'C'
assert letters.dequeue() is None
def test_enqueue_multiple():
q1 = Queue()
q1.enqueue(1)
q1.enqueue(2)
q1.enqueue(3)
q1.enqueue(4)
q1.enqueue(5)
assert q1.front.value == 1
assert q1.front.next.value == 2
assert q1.rear.value == 5
def test_dequeue_when_full():
q = Queue()
q.enqueue("apples")
q.enqueue("bananas")
actual = q.dequeue()
expected = "apples"
assert actual == expected
def test_dequeue():
q = Queue()
q.enqueue("apple")
q.enqueue("banana")
actual = q.dequeue()
expected = "apple"
assert actual == expected
def test_check_not_empty():
q = Queue()
q.enqueue("apple")
q.enqueue("banana")
actual = q.q_is_empty()
expected = False
assert actual == expected
def test_enqueue_two():
q = Queue()
q.enqueue("apples")
q.enqueue("bananas")
actual = q.peek()
expected = "apples"
assert actual == expected
def test_can_successfully_enqueue_multiple_values_into_a_queue():
new_queue = Queue()
new_queue.enqueue('Three')
new_queue.enqueue('Two')
new_queue.enqueue('One')
expected = 'Three'
actual = new_queue.peek()
assert expected == actual
def test_can_successfully_dequeue_out_of_a_queue_the_expected_value():
new_queue = Queue()
new_queue.enqueue('Three')
new_queue.enqueue('Two')
new_queue.enqueue('One')
expected = 'Three'
actual = new_queue.peek()
assert expected == actual
def test_stacks_and_queues_11 ():
queue = Queue()
queue.enquene('a')
queue.enquene('b')
queue.enquene('c')
actual = queue.peek()
expected = 'a'
assert actual == expected
def test_dequeue():
q2 = Queue()
q2.enqueue(7)
q2.enqueue(5)
q2.enqueue(3)
q2.enqueue(1)
assert q2.rear.value == 1
assert q2.dequeue() == 7
assert q2.front.value == 5
def breadthOrder(self):
'''
This method prints out the tree using a breadth-first approach that steps across the width of the tree before descending another level.
'''
ordered_list = []
tree_node_queue = Queue()
tree_node_queue.enqueue(self.root)
while not tree_node_queue.is_empty():
tree_node_removed_from_queue = tree_node_queue.dequeue()
ordered_list.append(tree_node_removed_from_queue.value)
if tree_node_removed_from_queue.left_node:
tree_node_queue.enqueue(tree_node_removed_from_queue.left_node)
if tree_node_removed_from_queue.right_node:
tree_node_queue.enqueue(
tree_node_removed_from_queue.right_node)
return ordered_list
def queue_test():
queue = Queue()
queue.enqueue(4)
queue.enqueue(3)
queue.enqueue(2)
queue.enqueue(1)
return queue
