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_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_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)
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
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')
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'
