def test_linkedqueue_front(self):
queue = LinkedQueue()
for i in range(100):
queue.enqueue(i + 1)
for i in range(100):
assert_equal(i + 1, queue.front())
queue.dequeue()
def stack_to_queue(my_stack):
s = deepcopy(my_stack)
q = LinkedQueue()
while not s.isEmpty():
q.add(s.peek())
s.pop()
return q
def rebalance(self):
"""
Re balances the tree.
:return: rebalanced tree
"""
def tmp(qq, lst):
tmp_lst = [lst]
while True:
new_tmp_lst = []
for l in tmp_lst:
if not l:
tmp_lst.remove(l)
continue
qq.add(l[len(l) // 2])
new_tmp_lst.append(l[:len(l) // 2])
new_tmp_lst.append(l[len(l) // 2 + 1:])
if not tmp_lst:
break
tmp_lst = new_tmp_lst
res = [i for i in qq]
return res
res = [i for i in self.in_order()]
q = LinkedQueue()
tmp_list = (tmp(q, res))
self.clear()
for each in tmp_list:
self.add(each)
def __init__(self, numOfPlayers=2):
self._numOfPlayers = numOfPlayers
self._totalScore = 0
self._deck = Deck()
self._queue = LinkedQueue()
for player in range(self._numOfPlayers):
self._queue.add(Player('Player ' + str(player + 1)))
self._currentPlayer = self._queue.pop()
def __init__(self):
"""
"""
self._totalCustomerWaitTime = 0
self._customersServed = 0
self._currentCustomer = None
self._queue = LinkedQueue()
def test_linkedqueue_dequeue(self):
queue = LinkedQueue()
for i in range(100):
queue.enqueue(i + 1)
for i in range(100):
assert_equal(i + 1, queue.dequeue())
assert_equal(99 - i, len(queue))
assert_equal(0, len(queue))
def __init__(self):
"""Maintains a queue of customers,
number of customers served, total customer wait time,
and a current customer being processed."""
self._totalCustomerWaitTime = 0
self._customersServed = 0
self._currentCustomer = None
self._queue = LinkedQueue()
def __init__(self, number):
"""Maintains a cashier number, a queue of customers,
number of customers served, total customer wait time,
and a current customer being processed."""
self.number = number
self.totalCustomerWaitTime = 0
self.customersServed = 0
self.currentCustomer = None
self.queue = LinkedQueue()
def __init__(self, data1, data2, summary):
"""This method initializes."""
self.data1 = data1
self.data2 = data2
self.summary = summary
self.queue = LinkedQueue()
self.total_food = 0
self.total_transport = 0
self.extrainfo = ""
self.see = ""
def test_push_to_queue(self):
name = "Jose"
phone = "123-456-7890"
node = Node(name, phone)
queue = LinkedQueue()
queue.push(node)
self.assertEqual(len(queue), 1)
def test_find_in_queue(self):
name = "Jose"
phone = "123-456-7890"
node = Node(name, phone)
queue = LinkedQueue()
queue.push(node)
self.assertEqual(queue.find(name), node)
def stack_to_queue(stack):
"""Return a queue that contains items from the stack."""
queue = LinkedQueue()
item_list = []
for item in stack:
item_list.insert(0, item)
for item in item_list:
queue.add(item)
return queue
def levelorder(self):
"""Supports a levelorder traversal on a view of self."""
lyst = list()
queue = LinkedQueue()
if not self.isEmpty():
queue.add(self.root)
while not queue.isEmpty():
node = queue.pop()
lyst.append(node.data)
if node.left != None:
queue.add(node.left)
if node.right != None:
queue.add(node.right)
return iter(lyst)
def bfs(g, start):
start.setDistance(0)
start.setPred(None)
vertQueue = LinkedQueue()
vertQueue.add(start)
while not vertQueue.isEmpty():
currentVert = vertQueue.pop()
for nbr in currentVert.getConnections():
if (nbr.getColor()) == 'white':
nbr.setColor('gray')
nbr.setDistance(currentVert.getDistance() + 1)
nbr.setPred(currentVert)
vertQueue.add(nbr)
currentVert.setColor('black')
def test_pop_from_queue(self):
name = "Jose"
phone = "123-456-7890"
node = Node(name, phone)
queue = LinkedQueue()
queue.push(node)
self.assertEqual(len(queue), 1)
popped = queue.pop()
self.assertEqual(popped, node)
self.assertEqual(len(queue), 0)
def breadthFirst(g, startLabel):
"""Returns a list of the vertex labels in the
order in which the vertices were visited."""
result = list()
g.clearVertexMarks()
queue = LinkedQueue()
queue.add(g.getVertex(startLabel))
while not queue.isEmpty():
vertex = queue.pop()
if not vertex.isMarked():
vertex.setMark()
result.append(vertex.getLabel())
for neighbor in g.neighboringVertices(vertex.getLabel()):
if not neighbor.isMarked():
queue.add(neighbor)
return result
def mazeSolver(maze, start, to_text=False, data_structure='stack'):
"""takes a maze and its starting point (as a tuple of row, column) and solves the maze. Maze walls must be *
characters and the ending point must be a "T" character. Free spaces must be an empty space, " ". """
# read the grid and set up stack
grid = maze_reader(maze)
print("maze without attempts:\n", grid)
if data_structure == 'stack':
_queue = LinkedStack()
else:
_queue = LinkedQueue(
) #TODO implement a linkedQueue structure with push
_queue.push(start)
# track choices:
choice_count = 0
#use stack data structure to explore maze and find a path to the end.
while not _queue.isEmpty():
_pop = _queue.pop()
# print("popping ",_pop)
if grid[_pop[0]][_pop[1]] == 'T':
choice_count += 1
print("Finished maze: \n")
print(grid)
if to_text:
maze_text(grid, "solution.txt")
return choice_count
else:
# if the _pop location did not return the character "T", leave a breadcrumb to not revisit.
if grid[_pop[0]][_pop[1]] != 'O' and grid[_pop[0]][
_pop[1]] != 'T' and grid[_pop[0]][_pop[1]] != 'P':
choice_count += 1
grid[_pop[0]][_pop[1]] = 'O'
# print("grid row, column is ",_pop[0],_pop[1],"\n")
# print(grid)
left = grid[_pop[0]][(_pop[1] - 1)]
right = grid[_pop[0]][(_pop[1] + 1)]
down = grid[(_pop[0] - 1)][_pop[1]]
up = grid[(_pop[0] + 1)][_pop[1]]
if left == ' ' or left == 'T':
_queue.push((_pop[0], (_pop[1] - 1)))
if right == ' ' or right == 'T':
_queue.push((_pop[0], (_pop[1] + 1)))
if up == ' ' or up == 'T':
_queue.push(((_pop[0] + 1), _pop[1]))
if down == ' ' or down == 'T':
_queue.push(((_pop[0] - 1), _pop[1]))
#if stack becomes empty, there is no path.
return choice_count
def levelorder(self):
"""Supports a levelorder traversal on a view of self."""
lyst = list()
# need a first in first out order, so use LinkedQueue
# add self._root to get while loop started
nodeStack = LinkedQueue([self._root])
while nodeStack:
currentNode = nodeStack.pop()
lyst.append(currentNode.data)
if currentNode.left:
nodeStack.add(currentNode.left)
if currentNode.right:
nodeStack.add(currentNode.right)
return iter(lyst)
def levelorder(self):
"""Supports a levelorder traversal on a view of self."""
our_list = []
our_queue = LinkedQueue()
def recurse():
if not our_queue.isEmpty():
node = our_queue.pop()
our_list.append(node.data)
if node.left is not None:
our_queue.add(node.left)
if node.right is not None:
our_queue.add(node.right)
recurse()
if not self.isEmpty():
our_queue.add(self._root)
recurse()
return iter(our_list)
def test_emptylinkedqueue_front(self):
queue = LinkedQueue()
val = queue.front()
import unittest
from linkedqueue import LinkedQueue
q = LinkedQueue()
for i in range(7):
q.add(i + 1)
class UnitTests(unittest.TestCase):
def test_unit_test(self):
self.assertEqual(len(q), 7)
q.clear()
self.assertEqual(len(q), 0)
def __init__(self):
self.stack1 = LinkedQueue()
self.stack2 = LinkedQueue()
def test_linkedqueue_ctor(self):
queue = LinkedQueue()
assert_equal(0, len(queue))
def stack_to_queue(StackObj):
""" takes a stack and transformes it to queue"""
queue = LinkedQueue()
for el in StackObj:
queue.add(el)
return queue
def test_emptylinkedqueue_dequeue(self):
queue = LinkedQueue()
val = queue.dequeue()
def __init__(self):
self.queue = LinkedQueue()
def breadthFirstTraverse(graph, startVertex, process):
traverseFromVertex(graph, startVertex, process, LinkedQueue())
def newQueue(self):
return LinkedQueue()
def __init__(self):
self._total_customer_wait_time = 0
self._customers_served = 0
self._current_customer = None
self._queue = LinkedQueue()
def test_linkedqueue_enqueue(self):
queue = LinkedQueue()
for i in range(100):
queue.enqueue(i + 1)
assert_equal(1, queue.front())
assert_equal(100, len(queue))
