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()))
