class MyQueue(object):
def __init__(self):
self.value = Queue()
def peek(self): #Enqueue element into the end of the queue.
self.value.append(object)
def pop(self): #dequeue the element at the front of the queue
tempStack = []
while self.value.isEmpty() != 1:
top = self.value.pop()
tempStack.append(top)
tempStack.pop
while tempStack.isEmpty() != 1:
top = tempStack.value.pop()
self.value.append(top)
def put(self, value): #Print the element at the front of the queue.
tempStack = []
while self.value.isEmpty() != 1:
top = self.value.pop()
tempStack.append(top)
frontElement = tempStack.pop() #pop the element to be printed out
print(frontElement) #print the first element from the queue
self.value.append(frontElement) #put the element back into the 'queue'
while tempStack.isEmpty() != 1:
top = tempStack.value.pop()
self.value.append(top)
def test_empty_queue(self):
queue = Queue(1)
self.assertAlmostEqual(queue.isFull(), False)
self.assertAlmostEqual(queue.isEmpty(), True)
queue.enqueue(12)
self.assertAlmostEqual(queue.isFull(), True)
self.assertAlmostEqual(queue.isEmpty(), False)
def getkeyword(keyword):
keys = getkeys()
consumer_key = keys[0]
consumer_secret = keys[1]
access_key = keys[2]
access_secret = keys[3]
line = keyword
words = line.split(',')
q = Queue(words)
video_num = 0
print(q.isEmpty())
print(q.length())
while not q.isEmpty():
word = q.items[0]
tImage = "images/" + str(video_num) + "-%01d.png"
video = word + ".avi"
tweets = readtweets(word, consumer_key, consumer_secret, access_key,
access_secret)
imageflow(video_num, tweets)
video_num = video_num + 1
subprocess.call(
['ffmpeg', '-y', '-framerate', '.1', '-i', tImage, video])
q.queuedown()
return keyword
class Queue_With_Max(object):
def __init__(self, currentindex=0):
self.maximums = Queue()
self.data = Queue()
self.current_index = currentindex
def push_back(self, number):
while not self.maximums.isEmpty() and number >= self.maximums.back().number_:
self.maximums.pop_back()
internaldata = Internal_Data(number, self.current_index)
self.data.push_back(internaldata)
self.maximums.push_back(internaldata)
self.current_index += 1
def pop_front(self):
if self.maximums.isEmpty():
raise KeyError('The queue is empty.')
if self.maximums.front().index_ == self.data.front().index_:
self.maximums.pop_front()
return self.data.pop_front()
def max(self):
if self.maximums.isEmpty():
raise KeyError('The queue is Empty.')
return self.maximums.front().number_
def simulation(numOfStd, pagePerMinute):
labPrinter = Printer(pagePerMinute)
printerQueue = Queue()
waitingTimes = []
currentSecond = 0
taskCnt = numOfStd * 2
while True:
if newPrintTask() and taskCnt > 0:
printerQueue.enqueue(Task(currentSecond))
taskCnt -= 1
if not labPrinter.busy() and not printerQueue.isEmpty():
nextTask = printerQueue.dequeue()
waitingTimes.append(nextTask.waitTime(currentSecond))
labPrinter.startNext(nextTask)
if taskCnt == 0 and not labPrinter.busy() and printerQueue.isEmpty():
break
labPrinter.tick()
currentSecond += 1
avgWait = sum(waitingTimes) / len(waitingTimes)
print("Average Wait %6.2f seconds %3d tasks ramaining"%(avgWait, printerQueue.size()))
def main():
q = Queue()
q.isEmpty()
q.enqueue(9)
q.enqueue(2)
q.enqueue(3)
q.isEmpty()
q.size()
q.peek()
q.print_list()
def main(): q = Queue() q.isEmpty() q.enqueue(9) q.enqueue(2) q.enqueue(3) q.isEmpty() q.size() q.peek() q.print_list()
def test_remove(self):
queue = Queue()
queue.add(1)
self.assertEqual(1, queue.remove())
self.assertTrue(queue.isEmpty())
queue.add(2)
queue.add(3)
self.assertEqual(2, queue.remove())
self.assertEqual(3, queue.remove())
self.assertTrue(queue.isEmpty())
class WordLadder:
"""A class providing functionality to create word ladders"""
stack = Stack()
# TODO:
# Implement whatever functionality is necessary to generate a
# stack representing the word ladder based on the parameters
# passed to the constructor.
def __init__(self, w1, w2, wordlist):
"""Initialize WordLadder class with five attributes
Args:
w1: user input word one
w2: user input word two
wordlist: a list of legal english word with a specified length
"""
self.w1 = w1
self.w2 = w2
self.wordlist = wordlist
self.wordqueue = Queue()
self.top_stack = Stack()
self.top_stack.push(w1)
self.wordqueue.enqueue(self.top_stack)
def make_ladder(self):
"""Create word ladder between two words
Returns:
A stack containing varying words that make up a word ladder
"""
created_word = {self.w1}
copy_word_list = self.wordlist.copy()
while not self.wordqueue.isEmpty():
top_stack = self.wordqueue.dequeue()
word = top_stack.peek()
for i in range(len(word)):
for ch in ascii_lowercase:
if ch != word[i]:
new_word = word[:i] + ch + word[i + 1:]
if (new_word in copy_word_list
and new_word not in created_word):
copy_word_list.remove(new_word)
created_word.add(new_word)
new_stack = top_stack.copy()
new_stack.push(new_word)
if new_word == self.w2:
return new_stack
else:
self.wordqueue.enqueue(new_stack)
if self.wordqueue.isEmpty():
return None
class TestQueue(unittest.TestCase):
def setUp(self):
self.q = Queue()
def test_all(self):
self.assertTrue(self.q.isEmpty())
self.q.enqueue(4)
self.q.enqueue('dog')
self.q.enqueue(True)
self.assertEqual(3, self.q.size())
self.assertFalse(self.q.isEmpty())
self.q.enqueue(8.4)
self.assertEqual(4, self.q.dequeue())
self.assertEqual('dog', self.q.dequeue())
self.assertEqual(2, self.q.size())
class WordLadder:
"""A class providing functionality to create word ladders"""
# Implement whatever functionality is necessary to generate a
# stack representing the word ladder based on the parameters
# passed to the constructor.
def __init__(self, w1, w2, wordlist):
"""given the two input words and wordlist,
initialize the constructor"""
self.wordlist = wordlist
self.queue = Queue()
self.w1 = w1
self.w2 = w2
# create alphabet list with letter a-z
self.alphabet = []
for letter in range(97, 123):
self.alphabet.append(chr(letter))
self.visited_words = set()
def make_ladder(self):
"""return the __str__ of the stack result"""
start_time = time.time()
# init the queue with a stack that contains w1
if self.queue.isEmpty():
stack = Stack()
stack.push(self.w1)
self.queue.enqueue(stack)
while not self.queue.isEmpty():
current_stack = self.queue.dequeue()
word = current_stack.peek()
for i in range(len(word)):
for letter in self.alphabet:
if letter != word[i]:
new_word_list = list(word)
new_word_list[i] = letter
new_word = "".join(new_word_list)
if (new_word in self.wordlist
and new_word not in self.visited_words):
self.visited_words.add(new_word)
if new_word == self.w2:
current_stack.push(new_word)
return current_stack.__str__()
else:
new_stack = current_stack.copy()
new_stack.push(new_word)
self.queue.enqueue(new_stack)
return None
def stack_using_queue():
q1 = Queue()
q2 = Queue()
choice = 1
while (choice != 0):
print("1. Push")
print("2. Pop")
choice = int(input(">"))
if choice == 1:
continue_add = 'y'
while (continue_add != 'n'):
q1.enqueue(input("Enter the item: "))
continue_add = input("Continue (y/n): ")
elif choice == 2:
if not q1.isEmpty():
for k in range(0, q1.size() - 1):
q2.enqueue(q1.dequeue())
print("The popped element is: {}".format(q1.dequeue()))
for t in range(0, q2.size()):
q1.enqueue(q2.dequeue())
else:
print("Queue empty")
def bfs(self, v, callback):
# Previous setting
d = {}
pred = {}
color = {}
for i in vertices:
color[i] = 'white'
d[i] = 0
pred[i] = None
queue = Queue()
queue.enqueue(v)
while not queue.isEmpty():
u = queue.dequeue()
neighbors = self.adjList.get(u)
color[u] = 'grey'
for n in neighbors:
if color[n] == 'white':
color[n] = 'grey'
# Count distance and set pred
d[n] = d[u] + 1
pred[n] = u
queue.enqueue(n)
color[u] = 'black'
print('distance is =>', d)
print('predecessors is =>', pred)
return pred
def buscaAmplitude(self,origin,destination): position = origin checked = [] queue = Queue() if (position == destination): return True checked.append(position) queue.enqueue(position) while(not queue.isEmpty()): position = queue.dequeue() if (position == destination): return True checked.append(position) neighbors = self.neighbors(position) while(len(neighbors) != 0): position = neighbors.pop(0) try: i = checked.index(position) except ValueError: i = -1 if (i == -1): if (position == destination): return True checked.append(position) queue.enqueue(position) return False
def BFS(g, s):
nodes = g.keys()
edges = [x for t in g.values() for x in t]
explored = dict(zip(nodes, [0 for i in nodes]))
dist = dict(zip(nodes, [99999 for i in nodes]))
dist[s] = 0
q = Queue()
q.enqueue(s)
if DEBUG_MODE: print "%s enqueued" % s
explored[s] += 1
if DEBUG_MODE: print "queue : %s" % q
if DEBUG_MODE: print "explored : %s" % explored
while not q.isEmpty():
v = q.dequeue()
if DEBUG_MODE: print "%s dequeued" % v
for k in g[v]:
if DEBUG_MODE: print "%s selected" % (k, )
if not explored[k[1]]:
explored[k[1]] += 1
dist[k[1]] = dist[v] + 1
q.enqueue(k[1])
if DEBUG_MODE: print "%s enqueued" % k[1]
else:
if DEBUG_MODE: print "%s already explored." % k[1]
if DEBUG_MODE: print "queue : %s" % q
if DEBUG_MODE: print "explored : %s" % explored
return explored, dist
def bfs(self, startNode):
"""
This is a function that performs a Breadth First Search
On the graph and prints out the order of the search
"""
queue = Queue()
# Mark all the nodes as not visited
visited = {}
for node in self.getNodes():
visited[node] = False
queue.enqueue(startNode)
while not queue.isEmpty():
s = queue.dequeue()
visited[s] = True
print s,
# enqueue all the adjacent vertices to s
# if they've not already been visited
for adjacentNode in self.getAdjacent(s):
if visited[adjacentNode] is False:
queue.enqueue(adjacentNode)
visited[adjacentNode] = True
def dfs(self, start, dest):
self.getVertex(start).setPrev(None)
q = Queue()
q.enqueue(start)
found = False
while not q.isEmpty() and not found:
name = q.dequeue()
if name == dest:
found = True
break
vetex = self.getVertex(name)
for tmpv in vetex.getConnections():
if tmpv.getColor() == "white":
tmpv.setColor("gray")
q.enqueue(tmpv.getId())
tmpv.setPrev(vetex)
vetex.setColor("black")
if found:
print("found")
tmp = self.getVertex(dest)
while tmp is not None:
print(tmp.getId(), end=" -> ")
tmp = tmp.getPrev()
else:
print("not found")
def simulation(numSeconds, pagesPerMinute):
"""
打印任务模拟
Args:
numSeconds:numSeconds 时间内模拟打印
pagesPerMinute:打印速度 pages/min
"""
labprinter = Printer(pagesPerMinute)
printQueue = Queue()
waitingtimes = []
for currentSecond in range(numSeconds):
if newPrintTask():
task = Task(currentSecond)
printQueue.enqueue(task)
#打印机空闲且队列不为空
if (not labprinter.busy()) and (not printQueue.isEmpty()):
#下一个任务
nexttask = printQueue.dequeue()
waitingtimes.append(nexttask.waitTime(currentSecond))
labprinter.startNext(nexttask)
labprinter.tick()
averageWait = sum(waitingtimes) / len(waitingtimes)
print("Average wait %6.2f secs %3d tasks remaining." %
(averageWait, printQueue.size()))
def buildNodeList(self):
result = {}
if self.root:
q = Queue()
visitedNode = []
q.enqueue(self.root)
q.enqueue('EndLevelFlag')
level = 0
while(not q.isEmpty()):
tmp = q.dequeue()
if tmp == 'EndLevelFlag':
# finish building the current level
level += 1
else:
# add node to Linked List
visitedNode.append(tmp)
if level in result.keys():
result[level].append(tmp)
else:
aList = LinkedList()
aList.append(tmp.value)
result[level] = aList
if tmp.left: q.enqueue(tmp.left)
if tmp.right: q.enqueue(tmp.right)
# add dummy item to represent the end of level
q.enqueue('EndLevelFlag')
return result
def deleteNode(root, data):
if root is None:
return
q = Queue()
node = None
deep = None
dleft = None
dright = None
result = []
q.enqueue(root)
while not q.isEmpty():
node = q.dequeue()
result.append(node.data)
if node.getLeft():
q.enqueue(node.getLeft())
if node.getLeft().data == data:
dleft = node
if node.getRight():
q.enqueue(node.getRight())
if node.getRight().data == data:
dright = node
root.printAllLevelOrder()
deep = node
if dleft is not None:
dleft.left = deep
node.data = data
elif dright is not None:
dright.right.data, node.data = deep.data, data
print("node here : ", deep, deep.data)
deep = None
root.printAllLevelOrder()
def baseConverter(decNum, base):
i_num = int(decNum)
i_base = int(base)
q = Queue()
while i_num != 0:
if i_base > i_num:
q.enqueue(i_num)
i_num = 0
elif i_num % i_base == 0:
c_num = i_num / i_base
q.enqueue(c_num)
i_num = i_num - i_base * c_num
else:
i = 1
multiple = i_base
while multiple < i_num:
i += 1
multiple = multiple * i
i_num = i_num - i_base * (i - 1)
q.enqueue(i - 1)
out = ''
while not q.isEmpty():
out += str(q.dequeue())
return out
def calcMinCoinNumForValue2(coinValueList, totalValue):
knownCoinNumForValue = {}
knownCoinChoice = {}
knownCoinChoice[0] = ''
q = Queue()
q.enqueue((0,0))
q.enqueue('endLevel') # flag indicating end of level
level = 1
cnt = 0
while(not q.isEmpty()):
e = q.dequeue()
if e== 'endLevel':
level+=1
q.enqueue('endLevel')
else:
currVal,valAdded = e
for vi in coinValueList:
if vi>=valAdded:
nextVal = currVal+vi
if nextVal==totalValue:
print str(vi)+' '+knownCoinChoice.get(currVal,'') # return empty string '' if knownCoinChoice[currVal] is undefined
print cnt
return level
elif nextVal>totalValue:
break
else:
cnt += 1
q.enqueue((nextVal,vi))
knownCoinNumForValue[nextVal]=level
if not knownCoinChoice.has_key(nextVal):
knownCoinChoice[nextVal] = str(vi)+' '+knownCoinChoice.get(currVal,'')
class QueueTest(unittest.TestCase):
def setUp(self):
self.myqueue = Queue()
def tearDown(self):
del(self.myqueue)
def test_create_empty_queue(self):
self.assertEqual(self.myqueue.isEmpty(), True)
def test_enqueue_element(self):
self.myqueue.enqueue(1)
self.assertEqual(self.myqueue.items[0], 1)
def test_dequeue_element(self):
self.myqueue.items.append(1)
self.assertEqual(self.myqueue.dequeue(), 1)
def test_ordering_enqueue_dequeue(self):
self.myqueue.enqueue(1)
self.myqueue.enqueue(2)
self.assertEqual(self.myqueue.dequeue(), 1)
self.assertEqual(self.myqueue.dequeue(), 2)
def test_queue_size(self):
self.myqueue.enqueue(1)
self.myqueue.enqueue(2)
self.myqueue.enqueue(3)
self.assertEqual(self.myqueue.size(), 3)
def BFS(self, board, x, y, replacement):
"""
:type board: List[List[str]]
:rtype: void Do not return anything, modify board in-place instead.
"""
if not board or not board[0]:
return
process = [False for l in board[0]]
processed = [process[:] for l in board]
q = Queue(len(board)*len(board[0]))
target = board[x][y]
q.enqueue((x,y))
print('target = ', target)
processed[x][y] = True
while(not q.isEmpty()):
(x1, y1) = q.dequeue()
board[x1][y1] = replacement
for r,c in zip(self.row, self.col):
#print r,c,len(q)
#if isvalid(self, x1+r,y1+c, board, processed, target):
i=x1+r
j=y1+c
if i>=0 and i<len(board) and j>=0 and j<len(board[0]) and board[i][j] == target and (not processed[i][j]):
q.enqueue((i,j))
# print r,c, i, j, board[i][j], processed[i][j], len(q)
processed[i][j] = True
return
def BFS(self, start_vertex):
start_vertex = self.get_vertex(start_vertex)
if start_vertex is None:
raise Exception(
"Vertex {} is not found in graph".format(start_vertex))
visited = [False] * len(self._vertices)
traversed = []
q = Queue()
q.enqueue(start_vertex)
while not q.isEmpty():
v = q.dequeue()
key = v.get_key()
if not visited[key]:
visited[key] = True
traversed.append(key)
for neighbor in v.get_connections():
if not visited[neighbor[0].get_key()]:
q.enqueue(neighbor[0])
return traversed
def make_ladder(self):
ASCII_VALUE_A = 97
ASCII_VALUE_Z = 122
stack = Stack()
queue = Queue()
stack.push(self.w1)
queue.enqueue(stack)
self.unique_word.add(self.w1)
while not queue.isEmpty():
stack1 = queue.dequeue()
word = stack1.peek()
for i in range(len(word)):
word_list = list(word)
for letter in range(ASCII_VALUE_A, ASCII_VALUE_Z + 1):
word_list[i] = chr(letter)
new_word = "".join(word_list)
if (new_word in self.wordlist
and new_word not in self.unique_word):
self.unique_word.add(new_word)
new_stack = stack1.copy()
new_stack.push(new_word)
if new_word == self.w2:
return new_stack
else:
queue.enqueue(new_stack)
else:
return None
def hasPathBFS(self, maze, start, destination):
m, n = len(maze), len(maze[0])
visited = [[False for _ in xrange(n)] for _ in xrange(m)]
q = Queue(m * n)
q.enqueue(start)
visited[start[0]][start[1]] = True
while not q.isEmpty():
(i, j) = q.dequeue()
if i == destination[0] and j == destination[1]:
return True
up, down, left, right = i, i, j, j
while up > 0 and maze[up - 1][j] != 1:
up -= 1
while down < len(maze) - 1 and maze[down + 1][j] != 1:
down += 1
while left > 0 and maze[i][left - 1] != 1:
left -= 1
while right < len(maze[0]) - 1 and maze[i][right + 1] != 1:
right += 1
if not visited[up][j]:
q.enqueue((up, j))
visited[up][j] = True
if not visited[down][j]:
q.enqueue((down, j))
visited[down][j] = True
if not visited[i][left]:
q.enqueue((i, left))
visited[i][left] = True
if not visited[i][right]:
q.enqueue((i, right))
visited[i][right] = True
return False
def test_queue_is_empty_after_last_item_is_dequeued(self): q = Queue() q.enqueue(1) q.dequeue() self.assertEquals(q.size(), 0) self.assertTrue(q.isEmpty()) self.assertIsNone(q.peek())
def simulation(seconds, ppm):
printer = Printer(ppm)
q = Queue()
waittimes = []
for currentSecond in range(seconds):
if newPrintTask():
task = Task(currentSecond)
q.enqueue(task)
if (not printer.isBusy()) and (not q.isEmpty()):
nextTask = q.dequeue()
waittimes.append(nextTask.getTimeWaited(currentSecond))
printer.startNextTask(nextTask)
printer.countdown()
averageWait = sum(waittimes)/len(waittimes)
print "Average wait of %6.2f seconds; %3d tasks remaining." \
% (averageWait, q.size())
return
def bfs(G, start):
state = {}
parentList = {}
order = []
# print "bfs started -- start :", start.name
for vert in G:
state[vert.name] = "undiscovered"
parentList[vert.name] = None
state[start.name] = "discovered"
Q = Queue()
Q.enqueue(start)
while Q.isEmpty() == False:
u = Q.dequeue()
order.append(u.name)
# print "Dequeued vertex", u.name
# print "vertex adjs "
# for v in u.connectedTo:
# print v.name,
# print ""
for v in u.connectedTo:
if state[v.name] == "undiscovered":
state[v.name] == "discovered"
parentList[v.name] = u.name
vert_v = G.getVertex(v.name)
if Q.contains(vert_v) == False:
Q.enqueue(vert_v)
# print "Enqueued new", v.name
state[u.name] = "processed"
return order
def bfs():
s = input("enter start node")
e = input("enter end node")
start = g.getVertex(s)
end = g.getVertex(e)
if not start:
print(f"{s} not in graph")
return
if not end:
print(f"{e} not in graph")
return
Q = Queue()
start.discovered = True
Q.push(start)
while not Q.isEmpty():
current = Q.pop()
if current.id == end.id:
break
for neighbour in current.connectedTo:
if not neighbour.discovered:
neighbour.discovered = True
neighbour.parent = current
Q.push(neighbour)
curr = end
while curr.parent is not None:
if curr.id.isupper():
print(f"was in {curr.id} with")
else:
print(f"{curr.id}")
curr = curr.parent
print(start.id)
def BFS(graph, size, src_node, hospitals, pred, k):
queue = Queue()
visited = [False] * size
hospitals_found = 0
hospital_list = [] # stores all the hospitals found
visited[src_node] = True
queue.EnQueue(src_node)
if str(src_node) in hospitals:
hospitals_found += 1
hospital_list.append(src_node)
while not queue.isEmpty() and hospitals_found < k:
current_node = queue.DeQueue()
for neighbor in graph[current_node]:
if not visited[neighbor]:
visited[neighbor] = True
pred[neighbor] = current_node
queue.EnQueue(neighbor)
if str(neighbor) in hospitals:
hospitals_found += 1
hospital_list.append(neighbor)
if hospitals_found >= k:
break
return hospital_list
def insertItem(root, item):
if root is None:
root = Tree(item)
return
newNode = Tree(item)
q = Queue()
node = None
q.enqueue(root)
while not q.isEmpty():
node = q.dequeue()
# for i in q.queue:
# print('i : ', i.data)
if node.getLeft():
q.enqueue(node.getLeft())
else:
node.left = newNode
break
if node.getRight():
q.enqueue(node.getRight())
else:
node.right = newNode
break
root.printAllLevelOrder()
def bfs(self, source, target, path):
source_vertex = self.get_vertex(source)
# Initially none of the nodes are visited
visited = [False] * len(self._vertices)
# Since we are starting at source, mark it visited and push it onto the queue
visited[source] = True
q = Queue()
q.enqueue(source_vertex)
# We need to exhaust all the items in the queue to see if there is an augmented path
# from source to target.
while not q.isEmpty():
current_vertex = q.dequeue()
current_vertex_key = current_vertex.get_key()
# For each of the edges(including reverse edges),
# if the other end of the edge is not visited and has a positive flow
# Mark it as visited and update the path to the node as the current vertex.
for neighbor in current_vertex.get_connections():
neighbor_vertex_key = neighbor[0].get_key()
if not visited[neighbor_vertex_key] and neighbor[1] > 0:
q.enqueue(neighbor[0])
visited[neighbor_vertex_key] = True
path[neighbor_vertex_key] = current_vertex_key
# Along the way, if we reach the target, we have found an augmented path.
if neighbor_vertex_key == target:
return True
# If the queue is exhausted, the no augmented path is available.
return False
def revKElements(input_string, k):
s = Stack()
q = Queue()
l_string = input_string.split(',')
n_string = l_string[:k]
print('L_string', l_string)
print(n_string, 'n_string')
for value in n_string:
q.enqueue(value)
print(q, "q")
while not q.isEmpty():
s.push(q.dequeue())
# for value in q:
# value = q.dequeue()
# s.push(value)
print(q, 'q2')
print(s, 's')
while not s.isEmpty():
q.enqueue(s.pop())
print(q)
print(list(q))
print(', '.join(list(q) + l_string[k:]), 'q3')
def wordLadderII(start, end, d):
q = Queue()
q.enqueue(start)
q.enqueue('endLevel')
h = {}
res = 1
visitedWord = []
while not q.isEmpty():
tmpWord = q.dequeue()
if tmpWord == 'endLevel':
res += 1
q.enqueue('endLevel')
else:
for i in range(len(tmpWord)):
for c in string.lowercase[:26]:
newWord = tmpWord[:i] + c + tmpWord[i+1:]
if newWord == end:
curr = [newWord]
prev = h.get(newWord,[tmpWord])
prev.extend(curr)
return prev
elif newWord in d:
prev = h.get(newWord,[tmpWord])
prevCopy = prev[:]
prevCopy.append(tmpWord)
h[newWord] = prevCopy
if newWord not in q and newWord not in visitedWord:
q.enqueue(newWord)
return 0
class BFS:
def __init__(self, node, graph):
self.src = 0
self.visited = []
self.node = node
self.graph = graph
self.queue = Queue()
self.dis = Queue()
for i in range(node):
self.visited.append(0)
def bfs(self, node):
self.src = node
self.queue.enqueue(node)
self.dis.enqueue(0)
#self.visit(node)
while not self.queue.isEmpty():
temp = self.queue.Back()
if self.visited[temp] == 0:
self.visit(temp)
for i in self.graph.g[temp]:
self.queue.enqueue(i)
self.dis.enqueue(self.dis.Back() + 1)
self.queue.dequeue()
self.dis.dequeue()
def visit(self, node):
print("node : ", node, " dis from ", self.src, " is : ",
self.dis.Back())
self.visited[node] = 1
def josephus(N, M):
q = Queue()
for i in range(N):
q.enqueue(i)
result = []
while not q.isEmpty():
for i in range(M-1):
q.enqueue(q.dequeue())
result.append(q.dequeue())
return result
def searchBFS(graph, start):
visited = []
queue = Queue()
queue.enqueue(start)
while not queue.isEmpty():
current = queue.dequeue()
if current not in visited:
visited.append(current)
for edges in graph[current]:
queue.enqueue(edges)
return visited
def breadthFirstSearchTraverse(self, startVertex): # use a queue to store the temporory vertex
vertexQueue = Queue()
if startVertex in self:
vertexQueue.enqueue(startVertex)
visitedVertex = []
while not vertexQueue.isEmpty():
currentVertex = vertexQueue.dequeue()
visitedVertex.append(currentVertex)
for neighborVertex in self.vertexList[currentVertex].getConnections():
if neighborVertex.id not in visitedVertex:
vertexQueue.enqueue(neighborVertex.id)
return visitedVertex
def solution(root):
if root is None: return []
q = Queue()
q.enqueue(root)
q.enqueue('EndLevel')
res = []
tmpRes = []
while not q.isEmpty():
tmp = q.dequeue()
if tmp == 'EndLevel':
res.append(tmpRes)
tmpRes = []
if not q.isEmpty():
# otherwise infinite loop
q.enqueue('EndLevel')
else:
tmpRes.append(tmp.val)
if tmp.left: q.enqueue(tmp.left)
if tmp.right: q.enqueue(tmp.right)
return res[::-1]
def ladderLength(start, end, dict):
q = Queue()
h, step = {}, 1
h[start] = 0
q.enqueue(start)
q.enqueue(0)
while not q.isEmpty():
curr = q.dequeue()
if curr == 0:
if q.isEmpty(): return h.get(end,0)
else:
q.enqueue(0)
step += 1
else:
for i in range(len(curr)):
for c in 'abcdefghijklmnopqrstuvwxyz':
tmp = curr[:i] + c + curr[i+1:]
if tmp == end: return step
if tmp in dict:
if tmp not in h:
q.enqueue(tmp)
h[tmp] = step
def zigzagLevel(root):
if root is None: return root
q = Queue()
q.enqueue(root)
q.enqueue('end')
level, currLevel, res = 0, [], []
while not q.isEmpty():
tmp = q.dequeue()
if tmp == 'end':
if level % 2: # flip odd level
currLevel = [r for r in currLevel[::-1]]
level += 1
res.append(currLevel)
currLevel = []
if not q.isEmpty():
q.enqueue('end')
else:
currLevel.append(tmp.value)
if tmp.left: q.enqueue(tmp.left)
if tmp.right: q.enqueue(tmp.right)
for r in res:
print r
def bfsIterative(node):
if node is None:
return []
res = []
q = Queue()
q.enqueue(node)
while not q.isEmpty():
tmp = q.dequeue()
res.append(tmp.value)
if tmp.left:
q.enqueue(tmp.left)
if tmp.right:
q.enqueue(tmp.right)
return res
def levelOrder(self,a):
q = Queue()
r = a
while r is not None:
print(r.root.data)
if r.root.left is not None:
q.add(r.root.left)
if r.root.right is not None:
q.add(r.root.right)
if q.isEmpty():
print("empty")
r = None
else:
r = q.delete()
class QueueTestCase(unittest.TestCase):
def setUp(self):
self.queue = Queue()
def test_isEmpty(self):
self.assertEqual(self.queue.isEmpty(),True)
def test_queue(self):
self.queue.enqueue(12)
self.queue.enqueue('queue')
self.queue.enqueue('end')
self.assertEqual(self.queue.size(),3)
self.assertEqual(self.queue.dequeue(),12)
self.assertEqual(self.queue.dequeue(),'queue')
self.assertEqual(self.queue.size(),1)
class Printer():
def __init__(self, speed):
self.speed = speed
self.queue = Queue()
def isIdle(self):
return self.queue.isEmpty()
def addTask(self, t):
self.queue.enqueue(t)
def removeTask(self):
if not self.queue.isEmpty():
return self.queue.dequeue()
def getQueueSize(self):
return self.queue.size()
def getTimeToFinishCurrentTask(self):
if self.queue.isEmpty():
return 0
else:
return self.queue.peek().getPage() / float(self.speed)
def BFS(graph, root, target):
q = Queue()
checked = []
q.enqueue(root)
path = 0
while not q.isEmpty():
v = q.dequeue()
if v == target:
return True
elif v not in checked:
for edge in graph[v]:
if v not in checked:
q.enqueue(edge)
checked.append(v)
return False
def main(g, start):
start.distance = 0
start.predecessor = None
q = Queue()
q.enqueue(start)
while not q.isEmpty():
current = q.dequeue()
print current
for nbrkey in current.getConnections():
if g.vertices[nbrkey].color == "white":
q.enqueue(g.vertices[nbrkey])
g.vertices[nbrkey].color = "grey"
g.vertices[nbrkey].distance = current.distance + 1
g.vertices[nbrkey].predecessor = current
current.color = "black"
def levelByLevel(self, aFile):
''' Print the nodes of the BTree level-by-level on aFile.
'''
aFile.write("A level-by-level listing of the nodes:\n")
aQueue = Queue() #create an empty queue
aQueue.enqueue(self.rootNode) #enqueue the root node
while not aQueue.isEmpty():
aNode = aQueue.dequeue() #get the next node in the queue
aFile.write(str(aNode)) #write the node to the file
for i in range(aNode.getNumberOfKeys()+1): #for each of the items in the node
child = self.readFrom(aNode.getChild()[i]) #get the child node
if child != None: #if there is a child node, enqueue it
aQueue.enqueue(child)
class Queue2Stack: def __init__(self,size1,size2): self.queue1 = Queue(size1) self.queue2 = Queue(size2) def push(self,data): self.queue1.push(data) def pop(self): while self.queue1.size!=1: self.queue2.push(self.queue1.pop()) result = self.queue1.pop() while not self.queue2.isEmpty(): self.queue1.push(self.queue2.pop()) return result
def levelOrder(root, result):
if root is None:
return
q = Queue()
q.enQueue(root)
while not q.isEmpty():
node = q.deQueue()
result.append(node.data)
if node.left :
q.enQueue(node.left)
if node.right:
q.enQueue(node.right)
return result
class test_queue(unittest.TestCase):
def setUp(self):
self.demo_queue = None
self.demo_queue = Queue(10)
def test_enqueue(self):
item1 = self.demo_queue.enqueue("1")
item2 = self.demo_queue.enqueue("2")
item3 = self.demo_queue.enqueue("3")
item4 = self.demo_queue.enqueue("4")
item5 = self.demo_queue.enqueue("5")
item6 = self.demo_queue.enqueue("6")
item7 = self.demo_queue.enqueue("7")
item8 = self.demo_queue.enqueue("8")
item9 = self.demo_queue.enqueue("9")
item10 = self.demo_queue.enqueue("10")
item11 = self.demo_queue.enqueue("11")
item12 = self.demo_queue.enqueue("12")
self.assertEqual(item1, True)
self.assertEqual(item2, True)
self.assertEqual(item3, True)
self.assertEqual(item4, True)
self.assertEqual(item5, True)
self.assertEqual(item6, True)
self.assertEqual(item7, True)
self.assertEqual(item8, True)
self.assertEqual(item9, True)
self.assertEqual(item10, True)
self.assertEqual(item11, False)
self.assertEqual(item12, False)
def test_dequeue(self):
item1 = self.demo_queue.enqueue("1")
item2 = self.demo_queue.enqueue("2")
item3 = self.demo_queue.enqueue("3")
self.assertEqual(self.demo_queue.dequeue(), True)
self.assertEqual(self.demo_queue.dequeue(), True)
self.assertEqual(self.demo_queue.dequeue(), True)
self.assertRaises(Exception, self.demo_queue.dequeue)
def test_isempty(self):
self.assertEqual(self.demo_queue.isEmpty(), True)
def cloneGraph(self, node):
if node is None: return node
q = Queue()
q.enqueue(node)
self.nodeCopy[node] = UndirectedGraphNode(node.label)
while not q.isEmpty():
oldNode = q.dequeue()
tmp = self.nodeCopy[oldNode]
for nb in oldNode.neighbors:
if nb not in self.nodeCopy:
''' define new neighbor node if not previous defined (unvisited) '''
self.nodeCopy[nb] = UndirectedGraphNode(nb.label)
q.enqueue(nb)
tmp.neighbors.append(self.nodeCopy[nb])
self.nodeCopy[oldNode] = tmp
return self.nodeCopy[node]
def simulation(numSeconds, pagesPerMinute, studentsNum, taskNumPerStudent, maxTaskLength):
labprinter = Printer(pagesPerMinute)
printQueue = Queue()
waitingtimes = []
for currentSecond in range(numSeconds):
if newPrintTask(studentsNum, taskNumPerStudent):
task = Task(currentSecond, maxTaskLength)
printQueue.enqueue(task)
if (not labprinter.busy()) and (not printQueue.isEmpty()):
nexttask = printQueue.dequeue()
waitingtimes.append(nexttask.waitTime(currentSecond))
labprinter.startNext(nexttask)
labprinter.tick()
averageWait = sum(waitingtimes) / len(waitingtimes)
return (averageWait, printQueue.size())
def simulation(numSeconds, pagesPerMinute):
labprinter = Printer(pagesPerMinute)
printQueue = Queue()
waitingtimes = []
for currentSecond in range(numSeconds):
if newPrintTask():
task = Task(currentSecond)
printQueue.enqueue(task)
if (not labprinter.busy()) and (not printQueue.isEmpty()):
nexttask = printQueue.dequeue()
waitingtimes.append(nexttask.waitTime(currentSecond))
labprinter.startNext(nexttask)
labprinter.tick()
averageWait = sum(waitingtimes)/len(waitingtimes)
print "Average Wait %6.2f secs %3d tasks remaining."%(averageWait,printQueue.size())
def wordLadder(start, end, d):
# assume correct input
q = Queue()
q.enqueue(start)
q.enqueue('endLevel')
visitedWord = []
res = 1
while not q.isEmpty():
tmpWord = q.dequeue()
if tmpWord == 'endLevel':
res += 1
q.enqueue('endLevel')
continue
visitedWord.append(tmpWord)
for i in range(len(tmpWord)):
for c in string.lowercase[:26]:
newWord = tmpWord[:i] + c + tmpWord[i+1:]
if end == newWord: return res
elif newWord in d and newWord not in visitedWord and newWord not in q:
q.enqueue(newWord)
return 0
def simulation(numSeconds, pagePerMinute, numStudents):
labprinter = Printer(pagePerMinute)
printQueue = Queue()
waitingTimes = []
avTaskpTime = numSeconds // numStudents
for currentSecond in range(numSeconds):
if newPrintTask(avTaskpTime):
task = Task(currentSecond)
printQueue.enqueue(task)
if (not labprinter.busy()) and (not printQueue.isEmpty()):
nextTask = printQueue.dequeue()
waitingTimes.append(nextTask.waitTime(currentSecond))
labprinter.startNext(nextTask)
labprinter.tick()
averageWait = sum(waitingTimes)/len(waitingTimes)
print("Average Wait %6.2f secs and %3d tasks remaining, %3d tasks are printed" %(averageWait, printQueue.size(), len(waitingTimes)))
#coding=latin1
'''
Created on 28 okt 2013
@author: MJ & YJ
'''
from queue import Queue
mening = input("Skriv en mening: ")
myq = Queue()
for ordet in mening.split(): # dela upp meningen i ord
myq.put(ordet) # och sätt in varje ord i kön
while not myq.isEmpty(): # alla köns element
print(myq.get()) # skrivs ut
print() # tom rad
print(myq.get()) # None skrivs ut eftersom kön är tom
