class Queue: def __init__(self): # initializes size of queue self.size = 0 # initializes items in storage self.storage = LinkedList() def enqueue(self, item): # adds another value to the tail of storage self.storage.add_to_tail(item) # when adding the new item to storage it increases storage size by one self.size += 1 def dequeue(self): # sets remove_value to the value of remove_head() remove_value = self.storage.remove_head() if remove_value == None: # if there is no value to remove then return None return None # if there is a value and it is removed, subtract 1 from storage size self.size -= 1 # return the value of removed item return remove_value def len(self): # returns the value of size return self.size
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def enqueue(self, item): # add_to_tail from linkedlist self.storage.add_to_tail(item) # add one to self.size self.size = self.size + 1 pass def dequeue(self): if self.size is not 0: # remove head from linked list deleted_value = self.storage.remove_head() # subtract 1 from size self.size = self.size - 1 return deleted_value pass def len(self): return self.size pass
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def enqueue(self, item): # => O(1) # Use add_to_tail method from LinkedList to add to the queue # Increment size by 1 for every enqueue self.storage.add_to_tail(item) # O(1) self.size += 1 # O(1) def dequeue(self): # => O(1) # Use remove_head method to dequeue # Want to return the dequeued_item because the test expects a return value # Decrement size by 1 for every dequeue as long as the size is not 0 dequeued_item = self.storage.remove_head() # O(1) if self.size > 0: # O(1) self.size -= 1 # O(1) return dequeued_item # O(1) def len(self): # => O(1) # Return the queue's size return self.size
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def __len__(self): return self.storage.length def enqueue(self, value): self.storage.add_to_tail(value) def dequeue(self): return self.storage.remove_head() def print_links(self): current = self.storage.head while current: print(current.value) current = current.get_next() # lynx = Queue() # lynx.enqueue('Super') # lynx.enqueue('kala') # lynx.enqueue('fragile') # lynx.enqueue('istic') # lynx.enqueue('expi') # lynx.enqueue('ali') # lynx.dequeue() # lynx.print_links()
class Queue: def __init__(self): self.size = 0 # what data structure should we # use to store queue elements? self.storage = LinkedList() def enqueue(self, item): self.storage.add_to_tail(item) return self.storage.tail.get_value() def dequeue(self): return f"{self.storage.head.get_value()} was removed" return self.storage.remove_head() def len(self): self.size = 0 if not self.storage.head and not self.storage.tail: return 0 if self.storage.head == self.storage.tail: return 1 current_value = self.storage.head while current_value: self.size += 1 current_value = current_value.get_next() return self.size
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def enqueue(self, item): self.storage.add_to_tail(item) self.size += 1 def dequeue(self): if self.size > 0: self.size -= 1 return self.storage.remove_head() def len(self): return self.size # testQueue = Queue() # print(testQueue.size) # testQueue.enqueue('hello') # print(testQueue.size) # testQueue.enqueue('hello1') # print(testQueue.size) # testQueue.enqueue('hello2') # print(testQueue.size) # print(testQueue.dequeue()) # print(testQueue.size) # print(testQueue.dequeue()) # print(testQueue.dequeue()) # print(testQueue.dequeue()) # print(testQueue.dequeue()) # print(testQueue.size)
class ListQueue: def __init__(self): self.size = 0 # Why is our DLL a good choice to store our elements? self.storage = LinkedList() def enqueue(self, value): self.storage.add_to_tail(value) self.size = self.storage.length if self.size != self.storage.length: return 'Error, underlying structures unsynced' def dequeue(self): if self.size == 0: return None val = self.storage.remove_from_head() self.size = self.storage.length return val def len(self): # enqueue / dequeue logic must adjust size given operation successful if self.size != self.storage.length: return 'Error, underlying structures unsynced' else: return self.size
class Stack: def __init__(self): self.size = 0 self.storage = LinkedList() def __len__(self): return self.size def push(self, value): self.storage.add_to_tail(value) self.size += 1 def pop(self): if self.size == 0: return None else: self.size -= 1 return self.storage.remove_tail()
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def enqueue(self, item): self.storage.add_to_tail(item) def dequeue(self): if self.storage.head is None: return None else: old_head = self.storage.head.value self.storage.remove_head() return old_head def len(self): head = self.storage.head if head is None: return 0 elif head.get_next() is None: return 1 else: count = 1 while head.get_next() is not None: count += 1 head = head.get_next() return count
def test_contains(): ll = LinkedList() for i in range(5): ll.add_to_tail(i) assert ll.contains(4) == True assert ll.contains(0) == True assert ll.contains(2) == True assert ll.contains(7) == False
def test_first_index(): ll = LinkedList() for i in range(5): ll.add_to_tail(i) assert ll.first_index(4) == 4 assert ll.first_index(0) == 0 assert ll.first_index(2) == 2 assert ll.first_index(7) == -1
def test_linked_list_add_to_tail(self): ll = LinkedList() ll.add_to_tail(3) self.assertEqual(3, ll.head.value) self.assertEqual(3, ll.tail.value) self.assertEqual(None, ll.head.next_node) self.assertEqual(None, ll.tail.previous_node) self.assertEqual(1, ll.count)
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def enqueue(self, item): self.size += 1 self.storage.add_to_tail(item) return self.size
def test_detect_cycle(): list_ = LinkedList() node1 = Node(100) node2 = Node(100) node3 = Node(100) for node in (node1, node2, node3): list_.add_to_tail(node) node3.set_next(node2) assert list_.detect_cycle() == node2
def test_linked_list_add_to_tail_two_nodes(self): ll = LinkedList() ll.add_to_tail(3) ll.add_to_tail(5) # 3 <-> 5 self.assertEqual(3, ll.head.value) self.assertEqual(5, ll.tail.value) self.assertEqual(5, ll.head.next_node.value) self.assertEqual(3, ll.tail.previous_node.value) self.assertEqual(2, ll.count)
def test_remove_first(): ll = LinkedList() for i in range(5): ll.add_to_tail(i) ll.remove_first(3) assert str(ll) == '0->1->2->4' ll.remove_first(6) assert str(ll) == '0->1->2->4' ll.remove_first(0) assert str('1->2->4')
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def enqueue(self, item): #INSERT operation self.storage.add_to_tail(item) pass def dequeue(self): #DELETE operation if self.storage.head == None: return None else: oldHead = self.storage.head.value self.storage.remove_head() return oldHead def len(self): currentNode = self.storage.head if currentNode == None: self.size = 0 return self.size if currentNode.get_next() == None: self.size = 1 return self.size else: counter = 1 while currentNode.get_next() != None: counter += 1 currentNode = currentNode.get_next() self.size = counter return self.size # queue1 = Queue() # queue1.enqueue(1) # queue1.enqueue(5) # queue1.enqueue(15) # queue1.enqueue(54) # print(queue1.storage.head.value) # print(queue1.storage.tail.value) # queue1.dequeue() # print(queue1.storage.head.value) # print(queue1.len()) # queue1.enqueue(100) # queue1.enqueue(101) # queue1.enqueue(105) # print(queue1.dequeue()) # assertEqual(queue1.dequeue(), 100)
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def __len__(self): return self.storage.length def enqueue(self, value): self.storage.add_to_tail(value) def dequeue(self): return self.storage.remove_head()
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def enqueue(self, item): self.storage.add_to_tail(item) def dequeue(self): return self.storage.remove_head def len(self): pass
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def enqueue(self, item): self.storage.add_to_tail(item) self.size = self.size + 1 def dequeue(self): if self.size is not 0: self.size = self.size - 1 return self.storage.remove_head() def len(self): return self.size
class Stack: ''' Stack() class built on Linked Lists ''' def __init__(self): self.size = 0 self.storage = LinkedList() def __len__(self): return self.storage.length def push(self, value): self.storage.add_to_tail(value) def pop(self): return self.storage.remove_tail()
class Queue: def __init__(self): self.storage = LinkedList() def __str__(self): return f"{self.storage}" def __len__(self): return len(self.storage) def enqueue(self, value): self.storage.add_to_tail(value) def dequeue(self): if len(self.storage) > 0: return self.storage.remove_from_head()
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def enqueue(self, item): self.storage.add_to_tail(item) self.size += 1 def dequeue(self): removed = self.storage.remove_head() if removed: self.size -= 1 return removed def len(self): return self.size
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def enqueue(self, item): self.size += 1 self.storage.add_to_tail(item) def dequeue(self): if self.size == 0: return None self.size -= 1 return self.storage.remove_head() def len(self): return self.size
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() #adding items def enqueue(self, item): self.storage.add_to_tail(item) self.size += 1 #deleting items def dequeue(self): # is a node in storage? if self.storage.head == None: return None else: prev_head = self.storage.head.value self.storage.remove_head() return prev_head #size of def len(self): current_head = self.storage.head if current_head == None: self.size = 0 return self.size if current_head.get_next() == None: self.size = 1 return self.size else: count = 1 while current_head.get_next() != None: count += 1 current_head = current_head.get_next() self.size = count return self.size return self.size
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def __len__(self): return self.size def enqueue(self, value): self.storage.add_to_tail(value) # O(1) self.size += 1 return value def dequeue(self): if self.size > 0: self.size -= 1 return self.storage.remove_head() # O(1) return None
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def enqueue(self, item): # Put value [item] into the queue self.size += 1 self.storage.add_to_tail(item) def dequeue(self): # Take a vaue of of the queue from the front if self.size is not None: self.size -= 1 return self.storage.remove_head() def len(self): return self.size
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def enqueue(self, item): self.storage.add_to_tail(item) def dequeue(self): return self.storage.remove_head() def len(self): amount_of_nodes = 0 current_node = self.storage.head while current_node is not None: amount_of_nodes += 1 current_node = current_node.next_node return amount_of_nodes
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def __len__(self): return self.size def enqueue(self, value): self.size += 1 self.storage.add_to_tail(value) def dequeue(self): if self.size == 0: return None else: self.size -= 1 return self.storage.remove_from_head()
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def enqueue(self, item): self.storage.add_to_tail(item) def dequeue(self): return self.storage.remove_head() def len(self): count = 0 temp = self.storage.head while temp: count += 1 temp = temp.next_node return count
def test_add_to_tail(): ll = LinkedList() assert str(ll) == '' for i in range(5): ll.add_to_tail(i) assert str(ll) == '0->1->2->3->4'