def levelorder(self): """ ------------------------------------------------------- Copies the contents of the tree in levelorder order to a 2D list. Use: values = bst.levelorder() ------------------------------------------------------- Postconditions: returns values - a list containing the values of bst in levelorder. (list of ?) ------------------------------------------------------- """ a = [] q = Queue() node = self._root if node is not None: q.insert(node) while not q.is_empty(): temp = q.remove() a.append(temp._value) if temp._left is not None: q.insert(temp._left) if temp._right is not None: q.insert(temp._right) return a
def test_queue01(self): q = Queue(10) q.enqueue(1) q.enqueue(2) q.enqueue(3) self.assertFalse(q.is_empty()) self.assertFalse(q.is_full()) self.assertEqual(q.size(), 3) self.assertEqual(q.dequeue(), 1)
def test_is_full(self): array = Queue(4) array.enqueue(1) self.assertFalse(array.is_full()) array.enqueue(2) array.enqueue(3) array.enqueue(4) self.assertTrue(array.is_full())
def test_dq(self): q = Queue(3) q.enqueue(1) q.enqueue(2) q.enqueue(3) q.dequeue() self.assertEqual(q.dequeue(), 2)
def test_none1(self): """Testing None""" q = Queue(5) q.enqueue(None) q.enqueue(1) self.assertFalse(q.is_empty()) self.assertFalse(q.is_full()) self.assertEqual(q.size(), 2)
def test_queue(self): q = Queue(5) self.assertEqual(q.is_empty(), True) self.assertEqual(q.is_full(), False) q.enqueue('thing') self.assertEqual(q.dequeue(), 'thing') self.assertEqual(q.size(), 0)
def queue_test(a): """ ------------------------------------------------------- Tests queue implementation. Use: queue_test(a) ------------------------------------------------------- Preconditions: a - list of data (list of ?) Postconditions: the methods of Queue are tested for both empty and non-empty queues using the data in a: empty, insert, remove, peek ------------------------------------------------------- """ q = Queue() # tests for the queue methods go here print("***Is_empty test 1: {}".format(q.is_empty())) print("***Array_to_queue ->") array_to_queue(q, a) print("***Is_empty test 2: {}".format(q.is_empty())) print("***Tests remove(): {}".format(q.remove())) print("***Peek test: {}".format(q.peek())) print("***Insert '21' to the back of the queue: ") q.insert(21) for v in q: print(v) # print the results of the method calls and verify by hand return
def level_order_list( self ): # return Python list of BST keys representing level-order traversal of BST # You MUST use your queue_array data structure from lab 3 to implement this method q = Queue(25000) # Don't change this! lst = [] q.enqueue(self.root) while not q.is_empty(): temp = q.dequeue() if temp is not None: lst.append(temp.key) q.enqueue(temp.left) q.enqueue(temp.right) return lst
def level_order_list(self): # (breadth first search) # return Python list of BST keys representing level-order traversal of BST # You MUST use your queue_array data structure from lab 3 to implement this method if self.is_empty(): raise IndexError("levelorder not possible, empty tree") key_list = [] q = Queue(25000) # Don't change this! HEIGHT = self.tree_height_helper(self.root) for desired_level in range(HEIGHT + 1): q = self.level_order_list_helper(q, self.root, HEIGHT, desired_level) while q.size() != 0: key_list.append(q.dequeue()) return key_list
def queue_test(a): """ ------------------------------------------------------- Tests queue implementation. Use: queue_test(a) ------------------------------------------------------- Preconditions: a - list of data (list of ?) Postconditions: the methods of Queue are tested for both empty and non-empty queues using the data in a: empty, insert, remove, peek ------------------------------------------------------- """ q = Queue() # tests for the queue methods go here # print the results of the method calls and verify by hand print("Empty queue: {}".format(q.is_empty())) for i in a: q.insert(i) print("Items inserted into queue:") for j in q: print("{}".format(j)) print() print("Remove: {}".format(q.remove())) print() if not q.is_empty(): print("Peek: {}".format(q.peek())) else: print("Queue is empty.") return
def test_queue(self): '''Trivial test to ensure method names and parameters are correct''' q = Queue(5) self.assertTrue(q.is_empty()) self.assertFalse(q.is_full()) q.enqueue('thing') self.assertEqual(q.dequeue(), 'thing') self.assertEqual(q.size(), 0)
def level_order_list( self ): # return Python list of BST keys representing level-order traversal of BST # You MUST use your queue_array data structure from lab 3 to implement this method q = Queue(25000) # Don't change this! q.enqueue(self.root) l = [] while not q.is_empty(): node = q.dequeue() l.append(node.key) if node.left != None: q.enqueue(node.left) if node.right != None: q.enqueue(node.right) return l
def level_order_list( self ): # return Python list of BST keys representing level-order traversal of BST # You MUST use your queue_array data structure from lab 3 to implement this method q = Queue(25000) # Don't change this! l = [] q.enqueue(self.root) if self.is_empty(): return l while q.size() > 0: x = q.dequeue() l.append(x.key) if x.left is not None: q.enqueue(x.left) if x.right is not None: q.enqueue(x.right) return l
def test_two(self): r = Queue(5) r.enqueue(1) r.enqueue(2) r.enqueue(3) self.assertEqual(r.num_items, 3) self.assertEqual(r.dequeue(), 1) self.assertEqual(r.dequeue(), 2) self.assertEqual(r.num_items, 1) with self.assertRaises(IndexError): while True: r.enqueue(1) self.assertEqual(r.num_items, r.capacity)
def test_is_empty(self): # DONE """Created and testing empty queue""" my_q = Queue(5) self.assertTrue(my_q.is_empty()) self.assertEqual(my_q.__repr__(), "Queue(5, [])") """Testing non-empty queue""" my_q.enqueue(3) self.assertFalse(my_q.is_empty())
def level_order_list( self ): # return Python list of BST keys representing level-order traversal of BST # You MUST use your queue_array data structure from lab 3 to implement this method q = Queue(25000) # Don't change this! nodelist = [] i = 0 returnlist = [] q.enqueue(self.root) while not q.is_empty(): nodelist.append(q.dequeue()) if nodelist[i].left != None: q.enqueue(nodelist[i].left) if nodelist[i].right != None: q.enqueue(nodelist[i].right) i += 1 for j in range(len(nodelist)): returnlist.append(nodelist[j].key) return returnlist
def test_is_empty(self): array = Queue(5) self.assertTrue(array.is_empty()) array.enqueue(1) self.assertFalse(array.is_empty())
def level_order_list( self ): # return Python list of BST keys representing level-order traversal of BST # You MUST use your queue_array data structure from lab 3 to implement this method q = Queue(25000) # Don't change this! if self.root == None: return [] else: q.enqueue(self.root) x = [] while q.num_items > 0: cur = q.dequeue() x += [cur.key] if cur.left != None: q.enqueue(cur.left) if cur.right != None: q.enqueue(cur.right) #self.root.lol(q) #print(q.items[:5]) #x = [] #for i in range(q.num_items): # x += [q.dequeue()] return x
def queue_test(a): """ ------------------------------------------------------- Tests queue implementation. Use: queue_test(a) ------------------------------------------------------- Preconditions: a - list of data (list of ?) Postconditions: the methods of Queue are tested for both empty and non-empty queues using the data in a: is_empty, insert, remove, peek ------------------------------------------------------- """ from queue_array import Queue q = Queue() q.insert(a[1]) q.peek() print(q.peek()) print(q.remove()) return
def queue_test(a): """ ------------------------------------------------------- Tests queue implementation. Use: queue_test(a) ------------------------------------------------------- Preconditions: a - list of data (list of ?) Postconditions: the methods of Queue are tested for both empty and non-empty queues using the data in a: empty, insert, remove, peek ------------------------------------------------------- """ q = Queue() for i in a: q.insert(i) print("Is the queue empty: {}".format(q.is_empty())) print("Removed: {}".format(q.remove())) print("Peek {}".format(q.peek())) return
import random from Patron import Patron from Server import Server from queue_array import Queue print("Welcome to the Dew-Drop Inn. Party Hearty - but Responsibly!") print() print("Please enter the following parameters:") run_time = int(input(" Run time (minutes): ")) number_servers = int(input(" Number of servers: ")) patrons_per_min = int(input(" Maximum number of patrons arriving per minute: ")) min_service_time = int(input(" Minimum service time (minutes): ")) max_service_time = int(input(" Maximum service time (minutes): ")) chance_of_rejection = float(input(" Chance of a patron being rejected: ")) q = Queue() servers = [] patron_count = 0 average_service_time = 0 past_queue_size = len(q) total_wait_time = 0 total_wait_time_left_over = 0 idle_time = 0 rejection = 0 for x in range(number_servers+1): s = Server(x+1, None) servers.append(s) for i in range(run_time): if past_queue_size < len(q): past_queue_size = len(q) print("Time {}".format(i))
def test_queue(self): '''Trivial test to ensure method names and parameters are correct''' q = Queue(5) q.is_empty() q.is_full() q.enqueue('thing') self.assertEqual(q.peek(), 'thing') q.dequeue() with self.assertRaises(IndexError): q.peek() q.size()
def test_queue2(self): q = Queue(3) q.enqueue(1) q.enqueue(2) q.enqueue(3) q.dequeue() q.dequeue() q.dequeue() q.enqueue(4) self.assertFalse(q.is_full())
def test_empty_queue(self): q = Queue(0) with self.assertRaises(IndexError): q.enqueue(1) with self.assertRaises(IndexError): q.dequeue()
def setUp(self): self.q = Queue()
def test_init(self): self.assertEqual(self.queue.get_size(), 0) new_queue = Queue("Bob") self.assertEqual(new_queue.get_size(), 1)
class TestStack(unittest.TestCase): def setUp(self): self.queue = Queue() def test_init(self): self.assertEqual(self.queue.get_size(), 0) new_queue = Queue("Bob") self.assertEqual(new_queue.get_size(), 1) def test_enqueue(self): self.queue.enqueue("Bob") self.assertEqual(self.queue.get_size(), 1) def test_dequeue(self): self.queue.enqueue("Bob") dequeued_item = self.queue.dequeue() self.assertEqual(dequeued_item, "Bob") another_dequeued_item = self.queue.dequeue() self.assertIsNone(another_dequeued_item) def test_peek(self): self.queue.enqueue("Bob") self.queue.enqueue("Bill") self.queue.enqueue("Boris") peeked_item = self.queue.peek() self.assertEqual(peeked_item, "Bob") def test_clear(self): for i in range(0, 100): self.queue.enqueue("Bob") self.assertEqual(self.queue.get_size(), 100) self.queue.clear() self.assertEqual(self.queue.get_size(), 0) def test_get_size(self): self.assertEqual(self.queue.get_size(), 0)
def test_queue(self): '''Trivial test to ensure method names and parameters are correct''' q = Queue(5) self.assertTrue(q.is_empty()) self.assertFalse(q.is_full()) q.enqueue('thing') self.assertEqual(q.dequeue(), 'thing') self.assertEqual(q.size(), 0) for i in range(5): q.enqueue(i) self.assertTrue(q.is_full()) self.assertFalse(q.is_empty()) with self.assertRaises(IndexError): q.enqueue(1) self.assertEqual(q.size(), 5) with self.assertRaises(IndexError): e = Queue(1) e.dequeue()
from queue_array import Queue q = Queue() print q.dequeue() # None q.enqueue('to') q.enqueue('be') q.enqueue('or') q.enqueue('not') q.enqueue('to') print q.dequeue() # to q.enqueue('be') print q.dequeue() # be print q.dequeue() # or q.enqueue('that') print q.dequeue() # not print q.dequeue() # to print q.dequeue() # be q.enqueue('is')
def setUp(self): self.queue = Queue()
def level_order_list( self ): # return Python list of BST keys representing level-order traversal of BST # You MUST use your queue_array data structure from lab 3 to implement this method q = Queue(25000) # Don't change this! pass
""" ---------------------------------------------------- q5.py Tests identical function. ---------------------------------------------------- Author: Qadeer Assan ID: 160257370 Email: [email protected] _updated_="2018-02-01" ---------------------------------------------------- """ from queue_array import Queue from asgn04 import identical q1 = Queue() q2 = Queue() q1.insert(0) q1.insert(2) q2.insert(0) q2.insert(2) b = identical(q1, q2) print("q1==q2: ", b) q3 = Queue() q4 = Queue() q3.insert(0) q3.insert(2) q4.insert(1) q4.insert(3) c = identical(q3, q4) print("q3==q4: ", c)
def test_queue(self): '''Trivial test to ensure method names and parameters are correct''' q = Queue(5) self.assertTrue(q.is_empty()) self.assertFalse(q.is_full()) q.enqueue(3) q.enqueue(5) self.assertEqual(q.size(), 2) q.enqueue(8) q.enqueue(9) q.enqueue(7) with self.assertRaises(IndexError): q.enqueue(8) self.assertFalse(q.is_empty()) self.assertTrue(q.is_full()) q.dequeue() self.assertEqual(q.dequeue(), 5) self.assertEqual(q.size(), 3) q.dequeue() q.dequeue() self.assertEqual(q.dequeue(), 7) self.assertEqual(q.size(), 0) with self.assertRaises(IndexError): q.dequeue() q.enqueue(3) q.enqueue(5) q.enqueue(7) q.enqueue(4) q.enqueue(8) self.assertEqual(q.dequeue(), 3) q.enqueue(2) q.dequeue() self.assertEqual(q.dequeue(), 7)
""" ---------------------------------------------------- ---------------------------------------------------- Author: Qadeer Assan ID: 160257370 Email: [email protected] _updated_="2018-02-01" ---------------------------------------------------- """ from queue_array import Queue q1 = Queue() q2 = Queue() q1.insert(0) q1.insert(2) q2.insert(0) q2.insert(2) b = q1.identical(q2) print("q1==q2: ", b) q3 = Queue() q4 = Queue() q3.insert(0) q3.insert(2) q4.insert(1) q4.insert(3) c = q3.identical(q4) print("q3==q4: ", c)
def line_up2(total_time, max_arrival_time, max_service_time, max_queue_size, number_servers): # initialize counters, queue, bool q = Queue() patron_id = 1 arriving = 0 serving = 0 max_queue = 0 patrons_served = 0 total_wait_time = 0 turned_away = 0 being_served = [] # loop through user inputted total_time for time in range(0, total_time + 1): if time != 0: print("Time = {}".format(time)) # determine when patrons join the queue if arriving == time: if len(q) == max_queue_size: turned_away += 1 if time != 0 and len(q) < max_queue_size: print(" Action: patron {} joins the queue.".format(patron_id)) patron = Patron(patron_id, copy.deepcopy(time)) q.insert(patron) patron_id += 1 if len(q) > max_queue: max_queue = len(q) arriving += random.randint(1, max_arrival_time) # determine when servers finish with patrons popped_index = [] if len(being_served) != 0: for i in range(len(being_served)): if being_served[i].end_service_time == time: print(" Action: patron {} finishes being served.".format(being_served[i].patron)) popped_index.append(i) patrons_served += 1 if len(popped_index) != 0: for i in range(len(popped_index), 0, -1): being_served.pop(popped_index[i - 1]) # determine when servers accept new patrons if len(being_served) < number_servers and q.is_empty() == False: print(" Action: patron {} starts the service.".format(q.peek().name)) serving = time serving += random.randint(1, max_service_time) server = Server(max_service_time, q.peek().name, serving) being_served.append(server) total_wait_time += time - q.peek().arrival_time q.remove() # display results print("Club is now closed") print("End simulation") print() print("The maximum queue size (longest line of patrons): {}".format(max_queue)) print("The number of patrons turned away: {}".format(turned_away)) print("The number of patrons served: {}".format(patrons_served)) print("The number of patrons left in the queue: {}".format(len(q))) print("The average time between arrivals (in minutes): {:.1f}".format(total_time / patron_id)) # if statement to avoid dividing by 0 if no patrons are served if patrons_served != 0: print( "The average wait time in the queue per patron (in minutes): {:.1f}".format( total_wait_time / patrons_served ) ) else: print("The average wait time in the queue per patron (in minutes): None") return