def find_new_room(self):
"""
Return a list containing the shortest path from
starting room to unknown room in
breadth-first order.
"""
# # initialize queue with starting vertex
q = Queue()
q.enqueue((self.seen[str(self.current_room['room_id'])], []))
# # set to keep track of vertexes already seen
visited = set()
# # while queue is not empty
while q.len() > 0:
# get path and vertex
room, path = q.dequeue()
# if room contains directions that have not been seen,
# append direction and return path
for direction, next_room in room['exits'].items():
if next_room == '?':
path.append(direction)
return path
# else, add room_id to visited
if room['room_id'] not in visited:
visited.add(room['room_id'])
# and add paths to the queue for each exit
for direction, next_room in room['exits'].items():
path_copy = path.copy()
path_copy.append(direction)
q.enqueue((self.seen[str(next_room)], path_copy))
raise ValueError('Room not found')
def bft_print(self, node):
#PLAN
#create/initialize queue
#add root to queue
#while queue is not empty
#pop head/top item out of queue & into temp variable [node = pop head of queue]
#if temp exists
# if there is temp var on the right
#put that into the queue on the right
# if there is a left temp var
#put that into the queue on the left
# DO the THING!... print temp value
# else break
queue = Queue()
queue.enqueue(node)
while queue.len() != 0:
temp: BinarySearchTree = queue.dequeue()
if temp:
if temp.right:
queue.enqueue(temp.right)
if temp.left:
queue.enqueue(temp.left)
print(temp.value)
else:
break
class RingBuffer:
def __init__(self, capacity):
self.capacity = capacity
self.current = None
self.storage = DoublyLinkedList()
self.order = Queue()
def append(self, item):
if len(self.storage) == self.capacity:
node = self.order.dequeue()
node.value = item
self.order.enqueue(node)
else:
self.storage.add_to_tail(item)
self.order.enqueue(self.storage.tail)
def get(self):
list_buffer_contents = [''] * len(self.storage)
node = self.storage.head
i = 0
while node:
list_buffer_contents[i] = node.value
i += 1
node = node.next
return list_buffer_contents
def bft_print(self, node):
"""
Iterative approach notes from lecture
Make a queue
add root to queue
while queue.length > 0
immediately pop root and save to a temp var (temp = queue.dequeue()) - with a queue, popping doesn't have to happen immediately
Do the thing
if temp.left add to queue
if temp.right add to queue
"""
# instantiating queue and adding initial node
level_queue = Queue()
level_queue.enqueue(node)
# while the queue has stuff in it
while level_queue.size > 0:
# removing current node and save it as current node
current_node = level_queue.dequeue()
# printing each current node
print(current_node.value)
# if there is a node to the right, also add that to queue
if current_node.right:
level_queue.enqueue(current_node.right)
# if there is a node to the right, also add that to queue
if current_node.left:
level_queue.enqueue(current_node.left)
def bft_print(self, node):
# Initialize a queue
queue = Queue()
# Push root to queue
queue.enqueue(node)
# While stack not empty
while queue.len() > 0:
# Pop item out of queue into temp
current_node = queue.dequeue()
# If temp has right, put into queue
if current_node.right:
# Ram it through method again
queue.enqueue(current_node.right)
# If temp has left, put into queue
if current_node.left:
# Ram it through method again
queue.enqueue(current_node.left)
# Print
print(current_node.value)
def bft_print(self, node):
#So to print every value in bredth
#we use as a queue as we call a node
#we put the child nodes at the back of the queue
#this enforces calling all nodes of one level before the next level of nodes are called
q = Queue()
#enqueue adds a value to the back of the line.
#to start the function we put the node passed in at the back/front of the queue
q.enqueue(node)
#now, while the queue is not empty...
while q.len() > 0:
#we take the node at the front of the queue
#and set it to current node
current_node = q.dequeue()
#print its value
print(current_node.value)
#if there is a node to the left, add it to the queu
if current_node.left:
q.enqueue(current_node.left)
#same for right
if current_node.right:
q.enqueue(current_node.right)
def find_room_by_id(self, id):
"""
Return a list containing the shortest path from
starting room to room with matching id in
breadth-first order.
"""
# # initialize queue with starting vertex
q = Queue()
q.enqueue((self.seen[str(self.current_room['room_id'])], []))
# # set to keep track of vertexes already seen
visited = set()
# # while queue is not empty
while q.len() > 0:
# get path and vertex
room, path = q.dequeue()
# if room title matches, return path
if room['room_id'] == id:
return path
# else, add room_id to visited
if room['room_id'] not in visited:
visited.add(room['room_id'])
# and add paths to the queue for each exit
for direction, next_room in room['exits'].items():
path_copy = path.copy()
path_copy.append(direction)
q.enqueue((self.seen[str(next_room)], path_copy))
raise ValueError('Room not found')
def find_nearest_unexplored(self, explored):
"""
Return a list containing the shortest path from
starting room to unexplored room in
breadth-first order.
"""
# initialize queue with starting vertex
q = Queue()
q.enqueue((self.seen[str(self.current_room['room_id'])], []))
# while queue is not empty
while q.len() > 0:
# get path and vertex
room, path = q.dequeue()
# if unexplored room, return path
if room['room_id'] in explored:
return path
# else, add room_id to explored
else:
explored.add(room['room_id'])
# and add paths to the queue for each exit
for direction, next_room in room['exits'].items():
path_copy = path.copy()
path_copy.append(direction)
q.enqueue((self.seen[str(next_room)], path_copy))
raise ValueError('No more rooms to explore')
def bft_print(self, node):
q = Queue()
q.enqueue(node)
while q.len() > 0:
current = q.dequeue()
print(current.value)
current.left and q.enqueue(current.left)
current.right and q.enqueue(current.right)
def bft_print(self, node):
to_print = Queue()
to_print.enqueue(node)
while to_print.len() > 0:
dequeued_node = to_print.dequeue()
print(dequeued_node.value)
dequeued_node.left and to_print.enqueue(dequeued_node.left)
dequeued_node.right and to_print.enqueue(dequeued_node.right)
def bft_print(self, node):
q = Queue()
q.enqueue(node)
while q.len() > 0:
t = q.dequeue()
print(t.value)
if t.left:
q.enqueue(t.left)
if t.right:
q.enqueue(t.right)
def bft_print(self, node):
storage = Queue()
storage.enqueue(self)
while storage.len():
current_node = storage.dequeue()
print(current_node.value)
if current_node.left:
storage.enqueue(current_node.left)
if current_node.right:
storage.enqueue(current_node.right)
def bft_print(self, node):
queue = Queue()
queue.enqueue(node)
while queue.len() > 0:
current = queue.dequeue()
print(current.value)
if current.left:
queue.enqueue(current.left)
if current.right:
queue.enqueue(current.right)
def bft_print(self, node):
queue = Queue()
queue.enqueue(node)
while queue.len() > 0:
temp = queue.dequeue()
print(temp.value)
if temp.left:
queue.enqueue(temp.left)
if temp.right:
queue.enqueue(temp.right)
def bft_print(self, node=None):
q = Queue()
q.enqueue(self)
while q.len() > 0:
node_current = q.dequeue()
print(node_current.value)
if node_current.left:
q.enqueue(node_current.left)
if node_current.right:
q.enqueue(node_current.right)
def bft_print(self, node):
queue = Queue()
queue.enqueue(node)
while queue.size > 0:
n = queue.dequeue()
print(n.value)
if n.left:
queue.enqueue(n.left)
if n.right:
queue.enqueue(n.right)
def bft_print(self, node):
queue = Queue()
queue.enqueue(node)
while queue.size > 0:
current = queue.dequeue()
if current.left is not None:
queue.enqueue(current.left)
if current.right is not None:
queue.enqueue(current.right)
print(current.value)
def bft_print(self, node):
q = Queue()
q.enqueue(node)
while q.size > 0:
popped = q.dequeue()
print(popped.value)
if popped.left:
q.enqueue(popped.left)
if popped.right:
q.enqueue(popped.right)
def bft_print(self, node):
queue = Queue()
queue.enqueue(node)
while queue.len() > 0:
head = queue.dequeue()
print(head.value)
if current_node.left is not None:
queue.enqueue(head.left)
if current_node.right is not None:
queue.enqueue(head.right)
def bft_print(self, node):
queue = Queue()
queue.enqueue(node)
while queue.size > 0:
curr_node = queue.dequeue()
print(curr_node.value)
if curr_node.left:
queue.enqueue(curr_node.left)
if curr_node.right:
queue.enqueue(curr_node.right)
def bft_print(self, node):
queue = Queue()
queue.enqueue(self)
while queue.size != 0:
popped = queue.dequeue()
print(popped.value)
if popped.left:
queue.enqueue(popped.left)
if popped.right:
queue.enqueue(popped.right)
def bft_print(self, node):
q = Queue()
q.enqueue(self)
while q.len() > 0:
current_node = q.dequeue()
if current_node.left:
q.enqueue(current_node.left)
if current_node.right:
q.enqueue(current_node.right)
print(current_node.value)
def bft_print(self, node):
q = Queue()
q.enqueue(node)
while q.len() > 0:
current_pop = q.dequeue()
print(current_pop.value)
if current_pop.left:
q.enqueue(current_pop.left)
if current_pop.right:
q.enqueue(current_pop.right)
def bft_print(self, node):
new_queue = Queue()
new_queue.enqueue(node)
while new_queue.size > 0:
current = new_queue.dequeue()
print(current.value)
if current.left:
new_queue.enqueue(current.left)
if current.right:
new_queue.enqueue(current.right)
def bft_print(self, node):
q = Queue()
q.enqueue(self)
while q.len() != 0:
node = q.dequeue()
print(node.value)
if node.left:
q.enqueue(node.left)
if node.right:
q.enqueue(node.right)
def bft_print(self, node):
queue = Queue()
temp_node = node
while temp_node:
print(temp_node.value)
if temp_node.left:
queue.enqueue(temp_node.left)
if temp_node.right:
queue.enqueue(temp_node.right)
temp_node = queue.dequeue()
def bft_print(self, node):
queue = Queue()
queue.enqueue(self)
while queue.len() > 0:
node = queue.dequeue()
print(node.value)
if node.left:
queue.enqueue(node.left)
if node.right:
queue.enqueue(node.right)
def bft_print(self, node):
q = Queue()
q.enqueue(node)
while q.len() > 0:
temp = q.dequeue()
print(temp)
if temp.left:
q.enqueue(temp.left)
if temp.right:
q.enqueue(temp.right)
def bft_print(self, node):
queue = Queue()
queue.enqueue(node)
while queue.len() > 0:
root = queue.dequeue()
print(root.value)
if root.left != None:
queue.enqueue(root.left)
if root.right != None:
queue.enqueue(root.right)
def bft_print(self, node):
q = Queue()
q.enqueue(starting_node)
while q.len() > 0:
current = q.dequeue()
print(current.value)
if current.left:
q.enqueue(current.left)
if current.right:
q.enqueue(current.right)
