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 __init__(self, value): self.value = value self.left = None self.right = None self.queue = Queue() self.stack = Stack() self.lastPrintedValue = -math.inf
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_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): #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 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): # 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_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): # 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): 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): self.queue = Queue(node) while self.queue.head is not None: self.queue.head.left.enqueue(self.value) self.queue.head.right.enqueue(self.value) print(self.queue)
def bft_print(self, node): queue = Queue() queue.enqueue(node.value) while queue.__len__() > 0: print(node.value) queue.dequeue() if node.left: node.bft_print(node.left) if node.right: node.bft_print(node.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): 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: 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: 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=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() 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(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): 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(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): 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): 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(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): 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 for_each(self, cb): if self.left: self.left.for_each(cb) if self.right: self.right.for_each(cb) return cb(self.value) queue = Queue() queue.enqueue(node)
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)