def stack_to_queue(stack):
copied = copy(stack)
# print(copied)
the_queue = ArrayQueue()
future_queue = []
while True:
try:
future_queue.append(copied.pop())
except KeyError:
return ArrayQueue(future_queue)
def queue_to_stack(queue):
"""
Converts the queue to a stack.
"""
stk_ar = ArrayStack()
q = ArrayQueue(queue)
el = []
while not q.isEmpty():
el.append(q.pop())
q1 = ArrayQueue(el[::-1])
while not q1.isEmpty():
stk_ar.push(q1.pop())
return stk_ar
def test_ArrayQueue_front(self):
queue = ArrayQueue()
for i in range(100):
queue.enqueue(i + 1)
for i in range(100):
assert_equal(i + 1, queue.front())
queue.dequeue()
def bf_traverse(self):
q = ArrayQueue()
if self.r != self.nil: q.add(self.r)
while q.size() > 0:
u = q.remove()
if u.left != self.nil: q.add(u.left)
if u.right != self.nil: q.add(u.right)
def test_ArrayQueue_dequeue(self):
queue = ArrayQueue()
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 stack_to_queue(stack):
"""
Converts the stack to a queue.
"""
q = ArrayQueue()
for i in list(stack)[::-1]:
q.add(i)
return q
def test_ArrayQueue_multipleoperations(self):
queue = ArrayQueue()
for i in range(100):
queue.enqueue(i + 100)
for i in range(50):
queue.dequeue()
for i in range(100):
queue.enqueue(i + 200)
assert_equal(150, queue.front())
def stackToQueue(stack):
stack_copy = copy.deepcopy(stack)
queue = ArrayQueue()
while True:
try:
queue.add(stack_copy.pop())
except KeyError:
break
return queue
def stack_to_queue(stack):
'''
Conver stack to queue.
'''
stack_copy = deepcopy(stack)
queue = ArrayQueue()
while stack_copy:
queue.add(stack_copy.pop())
return queue
def stack_to_queue(stack):
"""
Convert stack to queue
"""
queue = ArrayQueue()
while len(stack) != 0:
num = stack.pop()
queue.add(num)
return queue
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 = ArrayQueue()
def test():
Q = ArrayQueue()
Q.enqueue(5)
Q.enqueue(3)
print(Q.data)
print(Q.dequeue())
print(Q.is_empty())
print(Q.first())
print(Q.data)
def queue_to_stack(queue):
'''Convert queue to stack, without modifying the queue
peek of the stack must be first element of the queue'''
stack = ArrayStack()
queue_copy = ArrayQueue(queue)
while len(queue_copy) != 0:
stack.push(queue_copy.remove(len(queue_copy) - 1))
return stack
def stack_to_queue(stack):
'''Convert stack to queue, without changing given stack
peek of the stack is the first element in the queue'''
queue = ArrayQueue()
stack_copy = ArrayStack(stack)
while len(stack_copy) != 0:
queue.add(stack_copy.pop())
return queue
def stack_to_queue(stack):
"""Converts stack to a queue"""
start_stack = copy.deepcopy(stack)
output_queue = ArrayQueue()
while start_stack.isEmpty() is False:
elem = start_stack.pop()
output_queue.add(elem)
return output_queue
def stack_to_queue(stack):
"""
converts stack to queue
"""
stack_copy = ArrayStack(stack)
queue = ArrayQueue()
while True:
try:
element = stack_copy.pop()
queue.add(element)
except KeyError:
break
queue_reversed = ArrayQueue()
while True:
try:
element = queue.pop()
queue_reversed.add(element)
except KeyError:
break
return queue_reversed
def stack_to_queue(stack: ArrayStack) -> ArrayQueue:
"""
Converts stack to queue and returns Queue object
"""
queue = ArrayQueue()
copy_of_stack = deepcopy(stack)
while not copy_of_stack.isEmpty():
queue.add(copy_of_stack.pop())
return queue
def stack_to_queue(stack):
"""
Converts stack to queue.
"""
list_stack = []
for i in stack:
list_stack.append(i)
list_queue = list_stack[::-1]
new_queue = ArrayQueue()
for j in range(len(list_stack)):
new_queue.add(list_queue[j])
return new_queue
def stack_to_queue(stack):
"""
Converts stack to queue.
"""
temp_stack = ArrayStack()
result_queue = ArrayQueue()
while not stack.isEmpty():
elem = stack.pop()
result_queue.add(elem)
temp_stack.push(elem)
while not temp_stack.isEmpty():
stack.push(temp_stack.pop())
return result_queue
def stack_to_queue(stack):
"""
Return queue from stack (front of queue is peek of stack).
"""
copy_stack = ArrayStack()
queue = ArrayQueue()
for element in stack:
copy_stack.push(element)
while len(copy_stack) != 0:
queue.add(copy_stack.pop())
return queue
def queue_to_stack(queue: ArrayQueue) -> ArrayStack:
"""
Return stack from queue (front of queue is peek of stack).
"""
copy_queue = ArrayQueue()
stack = ArrayStack()
for element in queue:
copy_queue.add(element)
reversed_queue = reverse_queue(copy_queue)
for element in reversed_queue:
stack.push(element)
return stack
def __init__(self, numAgents, numMinutes, betweenTime, serviceTime):
# Parameters supplied by the user.
self._arriveProb = 1.0 / betweenTime
self._serviceTime = serviceTime
self._numMinutes = numMinutes
# Simulation components.
self._passengerQ = ArrayQueue()
self._theAgents = Array(numAgents)
for i in range(numAgents):
self._theAgents[i] = TicketAgent(i + 1)
# Computed during the simulation.
self._totalWaitTime = 0
self._numPassengers = 0
def queue_to_stack(queue):
"""
Converts queue to stack.
"""
temp_queue = ArrayQueue()
temp_stack = ArrayStack() #elements are in reversed order
result_stack = ArrayStack()
while not queue.isEmpty():
elem = queue.pop()
temp_queue.add(elem)
temp_stack.push(elem)
while not temp_queue.isEmpty():
queue.add(temp_queue.pop())
while not temp_stack.isEmpty():
result_stack.push(temp_stack.pop()) #we reverse elements
return result_stack
def main():
"""
tests module.
"""
queue = ArrayQueue()
for i in range(10):
queue.add(i)
stack = queue_to_stack(queue)
assert str(queue) == "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
assert str(stack) == "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]"
assert stack.pop() == 0
assert queue.pop() == 0
stack.add(11)
queue.add(11)
assert str(queue) == '[1, 2, 3, 4, 5, 6, 7, 8, 9, 11]'
assert str(stack) == "[9, 8, 7, 6, 5, 4, 3, 2, 1, 11]"
print("Success!")
def computeShortestPaths(self, srcIndex, use_heap):
self.source = srcIndex
nodes = self.network.getNodes()
self.distances = {}
self.previous_nodes = {}
for i in nodes:
self.distances[i.node_id] = math.inf
self.previous_nodes[i] = None
self.distances[self.source] = 0
t1 = time.time()
if not use_heap:
self.queue = ArrayQueue()
self.queue.make_queue(list(self.distances.keys()))
while self.queue.length > 0:
node_id = self.queue.deletemin(self.distances)
if node_id is not None:
for edge in nodes[node_id].neighbors:
# if current distance is greater than distance if we take another path
if self.distances[edge.dest.node_id] > (
self.distances[node_id] + edge.length):
self.distances[edge.dest.node_id] = self.distances[
node_id] + edge.length
self.previous_nodes[nodes[
edge.dest.node_id]] = nodes[node_id]
self.queue.decreasekey()
else:
self.queue = HeapQueue()
self.queue.make_queue(list(self.distances.keys()), self.distances)
while self.queue.length > 0:
node_id = self.queue.deletemin(self.distances)
if node_id is not None:
for edge in nodes[node_id].neighbors:
if self.distances[edge.dest.node_id] > (
self.distances[node_id] + edge.length):
self.distances[edge.dest.node_id] = self.distances[
node_id] + edge.length
self.previous_nodes[nodes[
edge.dest.node_id]] = nodes[node_id]
self.queue.decreasekey(edge.dest.node_id,
self.distances)
t2 = time.time()
return t2 - t1
def queue_to_stack(queue):
"""
converts queue to a stack
"""
queue_copy = ArrayQueue(queue)
stack = ArrayStack()
while True:
try:
element = queue_copy.pop()
stack.push(element)
except KeyError:
break
stack_reversed = ArrayStack()
while True:
try:
element = stack.pop()
stack_reversed.push(element)
except KeyError:
break
return stack_reversed
from arrayqueue import ArrayQueue
from arraystack import ArrayStack
import random
def queue_to_stack(queue):
"""
Convert queue to stack
"""
stack1 = ArrayStack()
stack2 = ArrayStack()
while len(queue) != 0:
num = queue.pop()
stack1.push(num)
while len(stack1) != 0:
num = stack1.pop()
stack2.push(num)
return stack2
if __name__ == '__main__':
queue = ArrayQueue()
stack = ArrayStack()
for i in range(random.randint(5, 10)):
m = random.randint(0, 10)
queue.add(m)
stack.push(m)
print('Stack: ', stack)
print('Queue: ', queue_to_stack(queue))
def stack_to_queue(stack):
queue = ArrayQueue()
new_stack = copy.deepcopy(stack)
while not new_stack.isEmpty():
queue.add(new_stack.pop())
return queue
from Queue.stack_to_queue import stack_to_queue from Stack.queue_to_stack import queue_to_stack from arraystack import ArrayStack from arrayqueue import ArrayQueue s = ArrayStack() s.push(1) s.push(2) s.push(3) q = stack_to_queue(s) print(s) print(q) q = ArrayQueue() q.add(1) q.add(2) q.add(3) s = queue_to_stack(q) print(s) print(q) print(s.pop())
def test_ArrayQueue_enqueue(self):
queue = ArrayQueue()
for i in range(100):
queue.enqueue(i + 1)
assert_equal(1, queue.front())
assert_equal(100, len(queue))
