def transform_bfs(start, target, h, t, flag): q = Queue() q.push(Word(start, True)) counter = 0 while not q.is_empty() and counter <= t: word = q.pop() options = generate_options(word.str) for opt in options: if opt in h: for candidate in h[opt]: if candidate.visited != flag: if candidate.visited == False: if compare(candidate.str, target) == 1: return word.ancestry + [ word.str, candidate.str, target ] else: candidate.visited = flag candidate.ancestry = word.ancestry + [word.str] q.push(candidate) counter += 1 else: return word.ancestry + [ word.str, candidate.str ] + candidate.ancestry[::-1] return None
def test_dequeue(self): q = Queue(['A', 'B', 'C']) assert q.dequeue() == 'A' assert q.length() == 2 assert q.dequeue() == 'B' assert q.length() == 1 assert q.dequeue() == 'C' assert q.length() == 0 assert q.is_empty() is True with self.assertRaises(ValueError): q.dequeue()
def bfs(land, r, c, rows, cols): q = Queue() land[r][c] = False q.push((r, c)) while not q.is_empty(): x, y = q.pop() for i, j in [(x, y + 1), (x, y - 1), (x + 1, y), (x - 1, y)]: if i in range(rows) and j in range(cols) and land[i][j]: land[i][j] = False q.push((i, j)) return
def test_enqueue(self): q = Queue() q.enqueue('A') assert q.front() == 'A' assert q.length() == 1 q.enqueue('B') assert q.front() == 'A' assert q.length() == 2 q.enqueue('C') assert q.front() == 'A' assert q.length() == 3 assert q.is_empty() is False
def bfs(gui, one_step=False): starting_pos = gui.grid.head.get_node() fringe = Queue() # Fringe holds a list of tuples: (node position, move to get prev to current, cost) fringe.enqueue([(starting_pos, None, 0)]) path = [] visited = [starting_pos] while not fringe.is_empty(): # Get the next one to be popped off the stack to search it's neighbor nodes (successors) path = fringe.dequeue() if gui.grid.grid[path[-1][0][0]][path[-1][0][1]] == 3: break for neighbor in get_neighbors(gui, path[-1][0][0], path[-1][0][1]): if neighbor[0] not in visited: updated_path = copy.copy(path) updated_path.append(neighbor) fringe.enqueue(updated_path) if not gui.grid.grid[neighbor[0][0]][neighbor[0][1]] == 3: visited.append(neighbor[0]) if not fringe.is_empty(): move_set = [] while path: temp = path.pop(0) if temp[1] is not None: move_set.append(temp[1]) if not one_step: return move_set else: return [move_set[0]] else: no_bfs_move = go_furthest(gui) if no_bfs_move: return no_bfs_move else: no_moves_at_all = go_down() return no_moves_at_all
def levelorder(self): items = [] queue = Queue() node = self._root # starting from the root queue.insert(node) # insert it while not queue.is_empty(): node = queue.remove() # pick that node items.append(node._data) # add to the list # if the left side is not None, there exist a left side, add the queue (going left to right_ if node._left is not None: queue.insert(node._left) # you also want to add the right side if node._right is not None: queue.insert(node._right) return items
def breadth_first_search_adjlist(graph, source, destination): if not source in graph.vertices: print('Source does not exist in graph') return if not destination in graph.vertices: print('destination does not exist in graph') return #Set inital parameters for source vert, enqueue source graph.vertex_object[source].color = 'grey' graph.vertex_object[source].distance = 0 graph.vertex_object[source].prev_search = None bfs_queue = Queue() bfs_queue.enqueue(source) #BFS while loop. Search closest nodes and set distances from source/build tree while not bfs_queue.is_empty(): current_vert = graph.vertex_object[bfs_queue.dequeue()] print(current_vert.name) for vertex in graph.vertices[current_vert.name]: if graph.vertex_object[vertex].color == 'white': graph.vertex_object[vertex].color = 'grey' graph.vertex_object[ vertex].distance = current_vert.distance + 1 graph.vertex_object[vertex].prev_search = current_vert.name bfs_queue.enqueue(vertex) print('Vertex:' + vertex) vertex_iterator = graph.vertex_object[destination] bfs_stack = [] while vertex_iterator != graph.vertex_object[source]: if not vertex_iterator.prev_search: print('No path between source and destination') return bfs_stack.append(vertex_iterator.name) vertex_iterator = graph.vertex_object[vertex_iterator.prev_search] bfs_stack.append(source) print([x for x in reversed(bfs_stack)])
def __str__(self): """ ------------------------------------------------------- Description: Returns a string representation of bst Uses Breadth First Search (BFS) Assert: none Use: str(bst) or print(bst) ------------------------------------------------------- Parameters: None Returns: output: string representation of bst (str) ------------------------------------------------------- """ q = Queue(self.MAX_SIZE) output = '' q.insert(self._root) level = 1 while not q.is_empty(): node = q.remove() if node is None: continue node_level = self.level(node._data) if node_level == level: output += '{} '.format(str(node._data)) elif node_level > level: output = '{}\n'.format(output[:-1]) output += '{} '.format(str(node._data)) level += 1 if node._left is not None: q.insert(node._left) if node._right is not None: q.insert(node._right) return output[:-1]
def _reflect_vertical_aux(self, node): queue = Queue() tree = BST() if node is None: return tree if node is not None: queue.insert(node) while not queue.is_empty(): temp = node._left node._left = node._right node._right = temp node = queue.remove() tree.insert(node._data) if node._left is not None: queue.insert(node._left) if node._right is not None: queue.insert(node._right) return tree
def __str__(self): """ ------------------------------------------------------- Description: Returns a string representation of bst Uses Breadth First Search (BFS) Assert: none Use: str(bst) or print(bst) ------------------------------------------------------- Parameters: None Returns: output: string representation of bst (str) ------------------------------------------------------- """ # You can all the way down print the depth (DFS depth first search) --> Stacks # Horizontal search, reads horizontally to prints (BFS breath first search) --> Queues q = Queue(self.MAX_SIZE) output = '' q.insert(self._root) level = 1 # come back to this in WEEK #11 while not q.is_empty(): node = q.remove() if node is None: continue node_level = self.level(node._data) if node_level == level: output += str(node._data) + ' ' elif node_level > level: output = output[:-1] + '\n' output += str(node._data) + ' ' level += 1 if node._left is not None: q.insert(node._left) if node._right is not None: q.insert(node._right) return output[:-1]
def reverse_stack(stack): """ ------------------------------------------------------- Description: Reverse a stack using a queue Use: reverse_stack(stack) ------------------------------------------------------- Parameters: stack - a stack of items (Stack) Returns: No returns ------------------------------------------------------- """ queue = Queue() while not stack.is_empty(): item = deepcopy(stack.pop()) queue.insert(item) while not queue.is_empty(): stack.push(queue.remove()) return
class AnimalShelter: def __init__(self): self.dogs = Queue() self.cats = Queue() self.counter = 0 def enqueue(self, *, name, species): if species in Animal.VALID_SPECIES: self.counter += 1 getattr(self, f"{species}s").push( Animal(name=name, species=species, counter=self.counter)) else: raise AttributeError("INVALID TYPE") def dequeue_cat(self): if self.cats.is_empty(): raise IndexError("EMPTY CAT QUEUE") else: return self.cats.pop().name def dequeue_dog(self): if self.dogs.is_empty(): raise IndexError("EMPTY DOG QUEUE") else: return self.dogs.pop().name def dequeue_any(self): if self.dogs.is_empty() and self.cats.is_empty(): raise IndexError("EMPTY QUEUE") elif self.dogs.is_empty(): return self.dequeue_cat() elif self.cats.is_empty(): return self.dequeue_dog() else: return self.dequeue_cat() if self.dogs.peek( ).counter > self.cats.peek().counter else self.dequeue_dog()
def test_nowa_kolejka_jest_pusta(self): q = Queue() self.assertTrue(q.is_empty())
from my_queue import Queue q = Queue(3) assert (q.is_empty()) assert (hasattr(q, "items")) assert (hasattr(q, "insert")) assert (hasattr(q, "remove")) assert (hasattr(q, "is_empty")) result = q.insert(5) assert (result == True) assert (not q.is_empty()) assert (q.__str__() == "5") result = q.insert(7) assert (result == True) assert (not q.is_empty()) assert (q.__str__() == "7 5") result = q.insert(-1) assert (result == True) assert (not q.is_empty()) assert (q.__str__() == "-1 7 5") result = q.insert(20) assert (result == False) assert (not q.is_empty()) assert (q.__str__() == "-1 7 5") result = q.insert(33) assert (result == False)
def test_is_empty(): queue = Queue() assert queue.is_empty() is True queue.enqueue(1) assert queue.is_empty() is False
'''------------Second Part--------------''' # user enters str values into stack line = input("Enter a string,'end' to stop: ") while (line != 'end'): stack.push(line) line = input("Enter a string,'end' to stop:") # user typed str values are removed from stack and printed while not(stack.is_empty()): print(stack.pop()) '''-------------Third Part----------------''' # same user interaction as before, except use a Queue instead of Stack queue = Queue() line = int(input("Enter a string,'end' to stop: ")) while (line != 'end'): queue.enqueue(line) #convert line to an int unless it is 'end' line = (input("Enter a string,'end' to stop:")) if line != 'end': line = int(line) product = 1 while not(queue.is_empty()): product *= queue.dequeue() print(product)
def test_init(self): q = Queue() assert q.front() is None assert q.length() == 0 assert q.is_empty() is True
def test_init_with_list(self): q = Queue(['A', 'B', 'C']) assert q.front() == 'A' assert q.length() == 3 assert q.is_empty() is False
def test_po_dodaniu2_i_usunieciu1_elementu_kolejka_nie_jest_pusta(self): q = Queue() q.enqueue(123) q.enqueue(456) q.dequeue() self.assertFalse(q.is_empty())
def test_po_dodaniu_i_usunieciu_elementu_kolejka_jest_pusta(self): q = Queue() q.enqueue(123) q.dequeue() self.assertTrue(q.is_empty())
def test_po_dodaniu_elementu_kolejka_nie_jest_pusta(self): q = Queue() q.enqueue(123) self.assertFalse(q.is_empty())