def BFS(G,s): """ Breadth First Search a Graph """ color = {} distance = {} parent = {} Q = Queue([]) for vertex in G.getVertexes(): color[vertex] = 0 distance[vertex] = float('inf') parent[vertex] = None color[s] = 1 distance[s] = 0 parent[s] = None Q.enqueue(s) while len(Q) != 0: u = Q.dequeue() for i in G.getAdjacencyVertexes(u): if color[i] == 0: color[i] = 1 distance[i] = distance[u]+1 parent[i] = u Q.enqueue(i) color[u] = 2
class DepthFirstOrder: def __init__(self,digraph): self._pre = Queue() self._post = Queue() self._reversePost = Stack() self._marked = [False] * (digraph.v +1) for v in range(digraph.v +1): if self._marked[v] is False: self._dfs(digraph,v) def _dfs(self,dg,v): self._pre.enqueue(v) self._marked[v] = True for w in dg.adj(v): if self._marked[w] is False: self._dfs(dg,w) self._post.enqueue(v) self._reversePost.push(v) def pre(self): return self._pre def post(self): return self._post def reversePost(self): return self._reversePost
class LazyPrimMST: def __init__(self,ewg): #ewg is an edge weighted graph self.pq = MinPQ() self.marked = [False] * (ewg.v+1) self.mst = Queue() self._visit(ewg,0) while not self.pq.isEmpty(): e = self.pq.dequeue() v = e.either() w = e.other(v) if (self.marked[v] == True and self.marked[w] == True): continue self.mst.enqueue(e) if not self.marked[v] == True: self._visit(ewg,v) if not self.marked[w] == True : self._visit(ewg,w) def _visit(self,ewg,v): self.marked[v] = True for e in ewg.adj(v): if not self.marked[e.other(v)] == True : self.pq.enqueue(e) def edges(self): return self.mst
class DepthFirstOrder: def __init__(self, digraph): self._pre = Queue() self._post = Queue() self._reversePost = Stack() self._marked = [False] * (digraph.v + 1) for v in range(digraph.v + 1): if self._marked[v] is False: self._dfs(digraph, v) def _dfs(self, dg, v): self._pre.enqueue(v) self._marked[v] = True for w in dg.adj(v): if self._marked[w] is False: self._dfs(dg, w) self._post.enqueue(v) self._reversePost.push(v) def pre(self): return self._pre def post(self): return self._post def reversePost(self): return self._reversePost
def test_enqueue_should_enqueue_value(self): newObject = Queue(1) expectedResult = 'abc' newObject.enqueue(expectedResult) self.assertEqual(expectedResult, newObject.item.value)
def BFS(self): # keep a queue for BFS queue = Queue() # enqueue the start state to the queue as a tuple (state, parent_state) self.start_state.set_parent(State(None)) queue.enqueue(self.start_state) self.expanded.append((self.start_state.get_state(), None)) # keep looping whilst there's still states in the queue while queue.is_empty() != True and len(self.visited) <= 1000: # dequeue next state and add it to visited current_state = queue.front() parent_state = queue.dequeue().get_parent() children_states = self.get_children_states(current_state, parent_state) self.visited.append(current_state.get_state()) # add current states children states to the queue for child_state in children_states: queue.enqueue(child_state) self.expanded.append((child_state.get_state(), self.last_update(child_state, current_state))) # check if end state is found if current_state.get_state() == self.goal_state.get_state(): # end state found self.path(current_state) break
class AnimalShelter: def __init__(self): self.dogQueue = Queue() self.catQueue = Queue() def enqueue(self, newAnimal): if isinstance(newAnimal, Dog): self.dogQueue.enqueue(newAnimal) elif isinstance(newAnimal, Cat): self.catQueue.enqueue(newAnimal) else: assert(False) def dequeueAny(self): firstDog = self.dogQueue.peek() firstCat = self.catQueue.peek() if firstDog == None: return self.catQueue.dequeue() if firstCat == None: return self.dogQueue.dequeue() if firstDog.order < firstCat.order: return self.dogQueue.dequeue() else: return self.catQueue.dequeue() def dequeueDog(self): return self.dogQueue.dequeue() def dequeueCat(self): return self.catQueue.dequeue()
def ClinicSim(w): # simulation for doctor clinic Doctor0 = Doctor() patientQ = Queue() # creating The queue TimeWaiting = [] # create the waiting times alist for currentsec in range( w): # w is the time we enter ( 4 hours = 4*60*60 second) if random.randrange( 1, 361 ) == 360: #checks the probability of arrival of a patient at any given second patient = Patient(currentsec) #creating a file for the patient patientQ.enqueue(patient) # adding the patient to the queue if not Doctor0.busy() and not patientQ.isEmpty( ): # check if the doctor is not busy and if there is a patient nextp = patientQ.dequeue() # delete patient from queue TimeWaiting.append( nextp.waittime(currentsec) ) #calculate the waiting time then add it to the list of waiting times Doctor0.Nextp(nextp) #let the patient enter to the doctor Doctor0.tick() #checks for patients still at the doctor averagewait = sum(TimeWaiting) / len( TimeWaiting) # calculate the average wait print("Average Wait ", averagewait, " secs", patientQ.size(), " tasks remaining.")
class ConvertToBinaryWithQueue(): def __init__(self, value): self.value = value self.queue = Queue() def ToBinary(self): highest_power_of_two = 1 while highest_power_of_two * 2 < self.value: highest_power_of_two *= 2 while highest_power_of_two >= 1: if self.value // highest_power_of_two == 0: self.queue.enqueue("0") else: self.queue.enqueue("1") self.value %= highest_power_of_two highest_power_of_two /= 2 binary = "" while not self.queue.IsEmpty(): binary += self.queue.dequeue() return binary
def breadth_first_search(graph, root): graph_t = [node for node in graph if node != root] for node in graph_t: node.color = "white" node.distance = float('inf') node.parent = None root.color = "gray" root.distance = 0 root.parent = None Q = Queue() print "Start conditions:" print("graph: " + str(graph)) print("Q: " + str(Q)) Q.enqueue(root) # pdb.set_trace() while not Q.isEmpty(): print "Iteration:" u = Q.dequeue() for node in u.adjacent: v = getAssociatedNode(graph, node) if v.color == "white": v.color = "gray" v.distance = u.distance + 1 v.parent = u Q.enqueue(v) print("graph: " + str(graph)) print("Q: " + str(Q)) u.color = "black"
def test_rear(self): q = Queue() q.enqueue(1) q.enqueue(2) q.enqueue(3) r = q.dequeue() self.assertEqual(3, q.rear())
def crawl_word(self,word): f = FileHandling("crawl_"+word+".txt") q = Queue() count = 0 depth = 0 q.enqueue(self.mainurl) while not q.isEmpty(): cURL = q.dequeue() #time.sleep(1) source = requests.get(cURL) soup = BeautifulSoup(source.text,'html.parser') if soup.find(text=re.compile(word, re.I)) is not None: print(cURL) f.log_msg(cURL) count+=1 for link in soup.findAll("a"): #print(link.get("href")) ln = link.get("href") if ln is not None: #print(ln) full_url=self.filter(link.get("href")) if full_url != "": q.enqueue(full_url) if count > self.mcount: break print("Number of URL crawled:",count,"Depth of crawled data:",depth)
def breadth_first_tree_search(self, problem): queue = Queue() node = Node(problem.initial, None, None, 0) queue.enqueue(node) explored = [] #print("problem initial = ", problem.initial) while not queue.is_empty(): node = queue.dequeue() #print(node.state) if (problem.goal_test(node.state)): #print("goal reached: ", node.state) return node explored.append(node.state) problem.visited = len(explored) frontier_nodes = node.expand_frontier(problem) problem.time += len(frontier_nodes) #print("frontier: ", frontier_nodes.state) for fnode in frontier_nodes: #print(fnode) if (fnode != None and fnode.state not in explored): queue.enqueue(fnode) if (queue.size() > problem.frontier): problem.frontier = queue.size() return None
def BFS(graph): sequence = "" number_of_node = len(graph.keys()) # print("no nodes ",number_of_node) graph_queue = Queue(number_of_node) keys = list(graph.keys()) # print("keys: ",keys) graph_queue.enqueue(keys[0]) visited = {key: 0 for key in keys} visited[keys[0]] = 1 while (not graph_queue.isEmpty()): # print("queue ",graph_queue.display()) node = graph_queue.dequeue() # print("node ",node) sequence += str(node) child_nodes = graph[node] # print("child:",child_nodes) for nodes in child_nodes: if not visited[nodes]: graph_queue.enqueue(nodes) visited[nodes] = 1 # print("visited: ",visited) return sequence
def simulateManyServer(num_secs, file_per_min, in_file, num_servers): request_list = [Server(file_per_min) for i in range(num_servers)] print_queue = Queue() waiting_times = [] with open(in_file) as lines: for line in lines: data = line.split(',') request = Request(int(data[0].strip()), data[1], int(data[2].strip())) print_queue.enqueue(request) current_server = 0 for current_second in range(num_secs): if (not request_list[current_server].busy()) and ( not print_queue.is_empty()): next_task = print_queue.dequeue() waiting_times.append(next_task.wait_time()) request_list[current_server].start_next(next_task) current_server = (current_server + 1) % len(request_list) for server in request_list: if server.busy: server.tick() average_wait = sum(waiting_times) / len(waiting_times) print("Average Wait %6.2f secs %3d tasks remaining." % (average_wait, print_queue.size()))
def test_dequeue1(self): q = Queue(5) q.enqueue(1) q.enqueue(2) assert q.dequeue() == 1
class LazyPrimMST: def __init__(self, ewg): #ewg is an edge weighted graph self.pq = MinPQ() self.marked = [False] * (ewg.v + 1) self.mst = Queue() self._visit(ewg, 0) while not self.pq.isEmpty(): e = self.pq.dequeue() v = e.either() w = e.other(v) if (self.marked[v] == True and self.marked[w] == True): continue self.mst.enqueue(e) if not self.marked[v] == True: self._visit(ewg, v) if not self.marked[w] == True: self._visit(ewg, w) def _visit(self, ewg, v): self.marked[v] = True for e in ewg.adj(v): if not self.marked[e.other(v)] == True: self.pq.enqueue(e) def edges(self): return self.mst
def imprimeNiv(self): s = "" nodo = self.node if (nodo is None): return q1 = Queue() q2 = Queue() q1.enqueue(self.node) while (not q1.isEmpty()) or (not q2.isEmpty()): while (not q1.isEmpty()): nodo = q1.dequeue() s = s + str(nodo.key) + " " #print(nodo.key) if (nodo.left.node is not None): q2.enqueue(nodo.left.node) if (nodo.right.node is not None): q2.enqueue(nodo.right.node) s = s + "\n" #print("\n") while (not q2.isEmpty()): nodo = q2.dequeue() s = s + str(nodo.key) + " " #print(nodo.key) if (nodo.left.node is not None): q1.enqueue(nodo.left.node) if (nodo.right.node is not None): q1.enqueue(nodo.right.node) s = s + "\n" #print("\n") return s
def topological_sort(graph): all_in_degrees = graph.compute_indegree_every_vertex() sort_result = [] q = Queue() for i in range(len(all_in_degrees)): if all_in_degrees[i] == 0: q.enqueue(i) while not q.is_empty(): u = q.dequeue() sort_result.append(u) for adj_vertex in graph.get_vertices_reachable_from(u): all_in_degrees[adj_vertex] -= 1 if all_in_degrees[adj_vertex] == 0: q.enqueue(adj_vertex) if len(sort_result) != graph.get_num_vertices(): return None return sort_result
class QStack(object): """ Use Queue to implement Stack q1 always contain items q2 uses for pop item iterate all items store from q1 to q2 keep the last q1 item, then pop it """ def __init__(self): self._q1 = Queue() self._q2 = Queue() self._size = 0 def is_empty(self): return self._size == 0 def push(self, item): print('Push item %d' %item) self._q1.enqueue(item) self._size += 1 def pop(self): if self.is_empty(): print('Stack is empty.') return None idx = self._size while idx > 1: self._q2.enqueue(self._q1.dequeue()) idx -= 1 else: item = self._q1.dequeue() self._size -= 1 self._q1, self._q2 = self._q2, self._q1 print('Pop item %d' %item) return item
class Stack: def __init__(self, limit): self.q1 = Queue(limit) self.q2 = Queue(limit) self.limit = limit self.curr_size = 0 def push(self, x): self.curr_size += 1 self.q1.enqueue(x) def pop_(self): if (self.q1.isEmpty()): print("Stack Underflow") return self.curr_size -= 1 while self.q1.size > 1: self.q2.enqueue(self.q1.dequeue()) elem = self.q1.dequeue() # swap the names of two queues self.q1, self.q2 = self.q2, self.q1 return elem def size(self): return self.curr_size def display(self): print("Stack:") for elem in self.q1.queue[::-1]: print("\t", elem)
def test_size(): """Test size method.""" from Queue import Queue q = Queue() q.enqueue(data[0]) q.enqueue(data[1]) assert q.size() == 2
def simulation(simulationTime, pagesPerMinute): # create a printer with a specific page rate labprinter = Printer(pagesPerMinute) printQueue = Queue() # waiting times list used for extracting meaningful content from the simulation waitingtimes = [] # run simulationTime seconds for currentSecond in range(simulationTime): if newPrintTask(): # create a new task if newPrintTask has randomly created a task task = printJob(currentSecond) # enqueue task to the print Queue printQueue.enqueue(task) # if printer is free and printQueue has jobs to process if (not labprinter.busy()) and (not printQueue.is_empty()): # process printJob nexttask = printQueue.dequeue() # keep track of how long printJob had to wait in the queue waitingtimes.append( nexttask.waitTime(currentSecond)) # start printing next task labprinter.startNextTask(nexttask) labprinter.tick() averageWait=sum(waitingtimes)/len(waitingtimes) print("Average Wait %6.2f secs %3d tasks remaining."%(averageWait,printQueue.size()))
def test_peek(): """Test peek method.""" from Queue import Queue q = Queue() q.enqueue(data[0]) q.enqueue(data[1]) assert q.peek() == data[1]
def crawl(self): f = FileHandling("crawl_all_links.txt") q = Queue() count = 0 depth = 0 q.enqueue(self.mainurl) while not q.isEmpty(): cURL = q.dequeue() time.sleep(1) source = requests.get(cURL) soup = BeautifulSoup(source.text,'html.parser') #print(cURL) count += 1 for link in soup.findAll("a"): #print(link.get("href")) ln = link.get("href") if ln is not None: full_url=self.filter(link.get("href")) if full_url != "": print(full_url) f.log_msg(full_url) q.enqueue(full_url) count+=1 depth+=1 if depth >= self.depth or count >= self.mcount: break print("Number of URL crawled:",count,"Depth of crawled data:",depth)
def test_dequeue(): """Test dequeue method.""" from Queue import Queue q = Queue() q.enqueue(data[0]) q.enqueue(data[1]) assert q.dequeue() == data[0]
def crawl_images(self,number): #f = FileHandling("crawl_all_links.txt") q = Queue() count = 0 q.enqueue(self.mainurl) while not q.isEmpty(): cURL = q.dequeue() time.sleep(1) source = requests.get(cURL) soup = BeautifulSoup(source.text,'html.parser') #print(cURL) for im in soup.findAll("img"): im_ln = im.get("src") if im_ln is not None: print(self.imgfilter(im_ln)) IMAGE = im_ln.rsplit('/',1)[1] try: urllib.request.urlretrieve(self.imgfilter(im_ln), self.imageout+IMAGE) count+=1 except: print("Invalid url...Ignoring") for link in soup.findAll("a"): #print(link.get("href")) ln = link.get("href") if ln is not None: #print(ln) full_url=self.filter(link.get("href")) if full_url != "": q.enqueue(full_url) if count > number: break print("Number of Images crawled:",count)
def simulation(numSeconds, pagesPerMinute): labprinter = Printer(pagesPerMinute) printQueue = Queue() waitingtimes = [] complete = [] # total time is 1 hour for currentSecond in range(numSeconds): print('currentSecond: ', currentSecond) if newPrintTask(): # if task is created, go into the Queue to wait task = Task(currentSecond) # timestamp for this task printQueue.enqueue(task) print('>>printQueue', printQueue) print('waitingtimes: ', waitingtimes) # add task if (not labprinter.busy()) and (not printQueue.isEmpty()): nexttask = printQueue.dequeue() # waiting time before printing: currentSecond - nexttask.timestamp waitingtimes.append(nexttask.waitTime(currentSecond)) print('>>printQueue', printQueue) print('waitingtimes for all tasks: ', waitingtimes) labprinter.startNext(nexttask) complete.append(nexttask) print('>>complete tasks and next task: ', complete) # start printing # when the timeremaining is 0 then the printer is available labprinter.tick() if waitingtimes != []: averageWait = sum(waitingtimes) / len(waitingtimes) print("Average Wait %6.2f secs %3d tasks remaining" % (averageWait, printQueue.size()))
class BFS(Search): def __initialize_BFS(self, wanted_node): self.__queue = Queue() self.visited_nodes = [] self.wanted_node = wanted_node def __is_new_node(self, node): return not node in self.visited_nodes and not self.__queue.contains( node) def __add_children(self, node): for node in self.graph.graph[node]: if self.__is_new_node(node): self.__queue.enqueue(node) def __call_recursive_BFS(self, node): self.visit(node) if self.is_wanted_node(node): return self.__add_children(node) self.__call_recursive_BFS(self.__queue.dequeue()) def BFS(self, wanted_node, starting_node=1): self.__initialize_BFS(wanted_node) if self.has_not_found_exception(): return self.__call_recursive_BFS(starting_node) return self.print_path()
def simulation(numSeconds, pagesPerMinute): labprinter = Printer(pagesPerMinute) printQueue = Queue() waitingtimes = [] number = 0 # 用循环模拟每一秒钟的情况 for currentSecond in range(numSeconds): # 有新任务时,任务入队 if newPrintTask(): number += 1 task = Task(currentSecond, number) logging.info('第{}秒,任务{}进入打印队列, 共{}页'.format(currentSecond, task.number, task.pages)) printQueue.enqueue(task) # 当打印机不忙,打印队列不为空时,开始下一个任务 if (not labprinter.busy()) and (not printQueue.isEmpty()): nexttask = printQueue.dequeue() waittime = nexttask.waitTime(currentSecond) logging.info('第{}秒,任务{}开始打印,等待了{}秒。'.format(currentSecond, task.number, waittime)) waitingtimes.append(waittime) labprinter.startNext(nexttask) # 执行打印逻辑 当前任务剩余时间 -1, 为0时结束任务 labprinter.tick(currentSecond) averageWait = sum(waitingtimes) / len(waitingtimes) logging.info("共执行了{}项打印任务,平均等待时间为{}秒, 打印队列里还有{}项任务".format\ (number, averageWait, printQueue.size()))
def test_enqueue_should_enqueue_when_full(self): newObject = Queue(1) newObject.enqueue(3) newObject.enqueue(4) self.assertEqual(4, newObject.item.value) self.assertEqual(1, newObject.itemCnt)
def hot_potato(namesList): simulationQueue = Queue() # create a Queue # initialize the Queue (first element in namesList is first into the Queue) for name in namesList: simulationQueue.enqueue(name) print(simulationQueue) def simulation(terminateCount): # Recursive approach to Hot Potato # base case condition if terminateCount <= 1: # ends recursion by starting destroying the recursive callStack return simulationQueue.dequeue() # recursive step else: # modify the list (rotate front of Queue member to back of Queue ) simulationQueue.enqueue(simulationQueue.dequeue()) # try simulation again with more random data Sets (reduce by 1 to eventually get near base Case) return simulation(randint(0, terminateCount-1)) return simulation
def bfs(g, start): """Breadth First Search Searching a graph and adjusting the vertex states. Args: g: a gragh start: a starting vertex. Returns: None Raises: None """ start.setDistance(0) start.setPred(None) vertQueue = Queue() vertQueue.enqueue(start) while vertQueue.size() > 0: currentVert = vertQueue.dequeue() for nbr in currentVert.getConnections(): if nbr.getColor() == 'white': nbr.setColor('grey') nbr.setDistance(currentVert.getDistance() + 1) nbr.setPred(currentVert) vertQueue.enqueue(nbr) currentVert.setColor('black')
def test_front(self): q = Queue() q.enqueue(1) q.enqueue(2) q.enqueue(3) r = q.dequeue() self.assertEqual(2, q.front())
def test_enqueue2(): a = Queue() a.enqueue(0) a.enqueue(1) a.enqueue(0) assert a.get_size() == 3 assert a.get_value() == 0 assert a.get_value_status() == 1
def n_binary(n): q = Queue() q.enqueue("1") for x in range(n): c = q.dequeue() print(c) q.enqueue(c + "0") q.enqueue(c + "1")
def test_enqueue_should_enqueue_values(self): newObject = Queue(3) newObject.enqueue(1) newObject.enqueue(2) newObject.enqueue(3) self.assertEqual(3, newObject.itemCnt)
def split(q): q1 = Queue() q2 = Queue() for i in range(len(q)): if i % 2: q1.enqueue(q.dequeue()) else: q2.enqueue(q.dequeue())
def test_dequeueing(self): q = Queue() q.enqueue(1) q.enqueue(2) q.enqueue(3) r = q.dequeue() self.assertEqual([2, 3], q.get_items()) self.assertEqual(1, r)
def hot_potato(name_list, num): sim_queue = Queue() for name in name_list: sim_queue.enqueue(name) while sim_queue.size() > 1: for i in range(num): sim_queue.enqueue(sim_queue.dequeue()) #sim_queue.dequeue() return sim_queue.dequeue()
def hotPotato(players, num): simQ = Queue() for p in players: simQ.enqueue(p) while simQ.size() > 1: for i in range(num): simQ.enqueue(simQ.dequeue()) simQ.dequeue() return simQ.dequeue()
class animatedLinkedList: def __init__(self): window = Tk() window.title("Linked List") self.lst = Queue() self.canvas = Canvas(window, width = 400, height = 200) self.canvas.pack() frame = Frame(window) frame.pack() Label(frame, text = "Element").pack(side = LEFT) self.v1 = StringVar() self.v1.set("") Entry(frame, textvariable = self.v1).pack(side = LEFT) self.lstx = 10 self.lsty = 80 self.bx = 10 self.by = 100 Button(frame, text = "Insert (enqueue)", command = self.insert).pack(side = LEFT) Button(frame, text = "Delete (dequeue)", command = self.delete).pack(side = LEFT) window.mainloop() def insert(self): if self.v1.get() == "": tkinter.messagebox.showerror("Error", "No input in element") else: self.lst.enqueue(int(self.v1.get())) self.update() def delete(self): self.lst.dequeue() self.update() def update(self): self.canvas.delete(ALL) x = self.lst.getSize() self.lstx = 10 self.lsty = 80 self.n = self.lst.__str__() self.n = self.n.split(", ") if len(self.n) > 1: a = self.n[0] self.n[0] = a.replace("[", "") b = self.n[len(self.n) - 1] self.n[len(self.n) - 1] = b.replace("]", "") elif len(self.n) == 1: a = self.n[0] a = a.replace("[", "") a = a.replace("]", "") self.n[0] = a print(self.n) for i in range(x): self.canvas.create_rectangle(self.lstx, self.lsty, self.lstx + 30, self.lsty + 20) self.canvas.create_text(self.lstx + 15, self.lsty + 10, text = self.n[i]) self.lstx += 30
def hot_potato(l, num): q = Queue() for i in l: q.enqueue(i) while q.size() > 1: for j in range(num): q.enqueue(q.dequeue()) q.dequeue() return q.dequeue()
def printTreeInLevelOrder(self, root): """ 1 2 3 4 5 6 7 """ q = Queue() q.enqueue(root) node = q.dequeue() print node.data
def josephus(namelist, num): simqueue = Queue() for name in namelist: simqueue.enqueue(name) while simqueue.size() > 1: for i in xrange(num): simqueue.enqueue(simqueue.dequeue()) simqueue.dequeue() return simqueue.dequeue()
def _bfs(self,graph,s): q = Queue() self.makred[s] = True q.enqueue(s) while not q.isEmpty(): v = q.dequeue() for w in graph.adj(v): if self.makred[w] is False: self.edgeTo[w] = v self.makred[w] = True q.enqueue(w)
def build_queue(data_list): q = Queue() for data in data_list: q.enqueue(data) q.display() print(q.length()) for i in range(1): # print(q.peek()) q.enqueue(q.dequeue()) q.display()
def bfs(self, graph, s): ##bfs中使用的队列 queue = Queue() self.marked[s] = True queue.enqueue(s) while not queue.is_empty(): ##从queue中删除一个节点 v = queue.dequeue() for w in graph.getAdj(v): if not self.marked[w]: self.edgeTo[w] = v self.marked[w] = True queue.enqueue(w)
def BFS(self,start): start.setDistance(0) vertQueue= Queue() vertQueue.enqueue(start) while(vertQueue.size()>0): currentVert=vertQueue.dequeue() for nbr in currentVert.getConnections(): if(nbr.getColor()=="white"): nbr.setColor("gray") nbr.setDistance(currentVert.getDistance()+1) nbr.setPred(currentVert) vertQueue.enqueue(nbr) currentVert.setColor("black")
def bfs(g,start): start.setDistance(0) start.setPred(None) vertQueue = Queue() vertQueue.enqueue(start) while (vertQueue.start() > 0): currentVert = vertQueue.dequeue() for nbr in currentVert.getconnections(): if (nbr.getcolor() == 'white'): nbr.setColor('gray') nbr.setDistance(currentVert.getDistance() + 1) nbr.setPred(currentVert) vertQueue.enqueue(nbr) currentVert.setColor('black')
def BFS(self): # n = QNode(self.root) Q = Queue(self.root) while(Q.size > 0): n = Q.head if n.data is not None: # we have a leaf node skip Q.enqueue(QNode(n.data.left)) Q.enqueue(QNode(n.data.right)) old = Q.dequeue() if old.data is None: print "," else: print old.data.value return Q
def hotPotato(players): if players is None or len(players) <= 1: return players simQ = Queue() plsize = len(players) for p in players: simQ.enqueue(p) while simQ.size() > 1: r = random.randint(plsize, plsize*2) for i in range(r): simQ.enqueue(simQ.dequeue()) simQ.dequeue() return simQ.dequeue()
def bfs1(graph,root,target): q = Queue() visited = [] q.enqueue(root) while not q.isEmpty(): removeNode = q.dequeue() if removeNode == target: return True elif v not in visited: for edge in graph[v]: if v not in visited: q.enqueue(edge) visited.append(v) return False
def simulation(num_seconds, pages_per_minute): lab_printer = Printer(pages_per_minute) print_queue = Queue() waiting_times = [] for current_second in range(num_seconds): if new_print_task(): task = Task(current_second) print_queue.enqueue(task) if (not lab_printer.busy()) and (not print_queue.is_empty()): next_task = print_queue.dequeue() waiting_times.append(next_task.wait_time(current_second)) lab_printer.startNext(next_task) lab_printer.tick() average_wait = sum(waiting_times) / len(waiting_times) print("Average Wait %6.2f secs %3d tasks remaining." %(average_wait, print_queue.size()) )
def BreadthFirstSearch(self,s): q = Queue(len(self.V)+1) for v in self.V: v.d = inf v.colour = white self.V[0].colour = grey self.V[0].d = 0 q.enqueue(self.V[0]) for v in q: for u in v.adjacent: if u.colour == white: u.d = v.d + 1 u.colour = grey if u.value == s: return u q.enqueue(u) v.colour = black
def simulation(seconds, ppm): printQueue = Queue() waitingtimes = [] printer = Printer(ppm) for currentSecond in range(seconds): if newPrintTask(): printQueue.enqueue(Task("Task"+str(currentSecond), currentSecond)) if (not printer.busy()) and (not printQueue.isEmpty()): nexttask = printQueue.dequeue() waitingtimes.append(nexttask.getWaitTime(currentSecond)) printer.nextTask(nexttask) printer.tick() lenWaitTime = len(waitingtimes) averageWait=sum(waitingtimes)/lenWaitTime print("Average Wait %6.2f secs %3d tasks remaining."%(averageWait,printQueue.size()))