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 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):
# queue = []
# if node:
# queue.append(node)
# while len(queue) > 0:
# print('val', queue[0].value)
# current_node = queue[0]
# if current_node.left_child:
# queue.append(current_node.left_child)
# if current_node.right_child:
# queue.append(current_node.right_child)
# queue.pop(0)
queue = Queue()
queue.enqueue(node)
while queue.len():
current_node = queue.dequeue()
print(current_node.value)
if current_node.left:
queue.enqueue(current_node.left)
if current_node.right:
queue.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 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 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):
# Check if this node is not empty
if node:
# Create a queue
my_queue = Queue()
# enqueue node
my_queue.enqueue(node)
# While the length of my_queue is not 0
while my_queue.len() != 0:
# save the last node in the queue in popped_node
# dequeue this last node from the queue
dequeued_node = my_queue.dequeue()
# print the value of popped_node
print(dequeued_node.value)
# If popped_node.left is not empty
if dequeued_node.left:
# Enqueue popped_node.left to the queue
my_queue.enqueue(dequeued_node.left)
# If popped_node.right is not empty
if dequeued_node.right:
# Enqueue popped_node.right to the queue
my_queue.enqueue(dequeued_node.right)
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
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:
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=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):
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):
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):
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:
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.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):
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:
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):
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):
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(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()
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(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)
def bft_print(self, node):
queue = Queue()
queue.enqueue(node)
while queue.len():
item = queue.dequeue()
print(item.value)
if item.left:
queue.enqueue(item.left)
if item.right:
queue.enqueue(item.right)
def bft_print(self, node):
queue = Queue()
queue.enqueue(node)
while queue.len():
current_node = queue.dequeue() # pop left
print(current_node.value) # d
if current_node.left:
queue.enqueue(current_node.left) # l
if current_node.right:
queue.enqueue(current_node.right) # r
"""
def for_each(self, cb):
current_node = self
queue = Queue()
queue.enqueue(current_node)
while queue.len() > 0:
current_node = queue.dequeue()
cb(current_node.value)
for item in [current_node.left, current_node.right]:
if item is not None:
queue.enqueue(item)
def bft_print(self, node):
q = Queue()
q.enqueue(node)
while q.len() > 0:
dq = q.dequeue()
print(dq.value)
if dq.left is not None:
q.enqueue(dq.left)
if dq.right is not None:
q.enqueue(dq.right)
def bft_print(self, node):
current_node = node
queue = Queue()
queue.enqueue(current_node)
while queue.len() > 0:
current_node = queue.dequeue()
print(current_node.value)
for item in [current_node.left, current_node.right]:
if item is not None:
queue.enqueue(item)
def bft_print(self, node):
queue_storage = Queue()
queue_storage.enqueue(node)
while queue_storage.len() > 0:
curr_node = queue_storage.dequeue()
print(curr_node.value)
if curr_node.left:
queue_storage.enqueue(curr_node.left)
if curr_node.right:
queue_storage.enqueue(curr_node.right)
def bft_print(self, node):
storage = Queue()
while True:
if node == None and storage.len() == 0:
break
elif node == None:
node = storage.dequeue()
else:
print(node.value)
storage.enqueue(node.left)
storage.enqueue(node.right)
node = storage.dequeue()
