class Stack: def __init__(self): self.size = 0 # self.storage = np.array([]) self.storage = LinkedList(None) def __len__(self): return self.size def __str__(self): print(self.storage) def push(self, value): # I'm going to assume that I'm pushing something onto the top of the stack # self.storage = np.append(self.storage, value) self.storage.add_to_tail(value) self.size += 1 return def pop(self): # I'm going to assume that I'm popping something off the top of the stack if self.size == 0: return None # else: # delvalue = self.storage[-1] # self.storage = self.storage[:-1] else: tail_value = self.storage.tail.value self.storage.remove_tail() self.size -= 1 return tail_value
class Stack: def __init__(self): self.size = 0 # self.storage = [] self.storage = LinkedList() def __len__(self): return self.size def push(self, value): # self.storage.append(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.pop() if self.size == 0: return None else: self.size -= 1 return self.storage.remove_tail()
class Stack: def __init__(self): self.size = 0 self.storage = LinkedList() def __len__(self): return self.size def push(self, value): # increase the size self.size += 1 # add value to top of stack self.storage.add_to_tail(value) def pop(self): # check the size to determine with method to use if self.size > 1: # reduce the size of the stack self.size -= 1 # remove the item on the top of the stack return self.storage.remove_tail() elif self.size == 1: # reduce the size of the stack self.size -= 1 # remove the item on the top of the stack return self.storage.remove_head()
class Queue: def __init__(self): self.size = 0 # self.storage = [] self.storage = LinkedList() def __len__(self): return self.size def enqueue(self, value): # index = self.size # self.storage.insert(index, value) self.storage.add_to_tail(value) self.size += 1 def dequeue(self): if self.size > 0: # first_index = 0 # del_value = self.storage[first_index] # del self.storage[first_index] # self.size -= 1 # return del_value del_value = self.storage.remove_head() self.size -= 1 return del_value
class Queue: """Singly-linked list implementation of Queue data structure""" def __init__(self): """Initialize singly-linked list-based Queue class""" self.size = 0 self.queue = LinkedList() def __len__(self): """Return length of Queue class""" return self.size def enqueue(self, value): """Add an element to initialized Queue class""" self.queue.add_to_tail(value) self.size += 1 def dequeue(self): """Remove least recently added element from Queue class""" if self.size == 0: return else: self.size -= 1 return self.queue.remove_head()
class Queue: def __init__(self): self.size = 0 # self.storage = ? self.storage = LinkedList() def __len__(self): return self.size def enqueue(self, value): # adds item to the back (tail) of the queue self.size += 1 # calling function add to tail to add item to the back of the queue self.storage.add_to_tail(value) def dequeue(self): # remove and return and item in front of the queue # if there are items if self.size > 0: # we are reducing the size by one self.size -= 1 # removing from head and returning that item return self.storage.remove_head() def len(self): # returns the number of items in the queue return self.size
class Queue: # Queue - Add (Enqueue) to the back of the queue (tail), # remove (Dequeue) from front (head). def __init__(self): # Initialize this queue to the empty queue self.size = 0 # Use the LinkedList class as storage self.storage = LinkedList() def __len__(self): return self.size def enqueue(self, value): self.storage.add_to_tail(value) # Creates a node from the value, # Checks if list is empty, # Adds value as tail self.size += 1 def dequeue(self): data = self.storage.remove_head() # Checks if list is empty, # Checks if head and tail are pointing at same node # If so, delete head and tail referance # Else set the new head to the node after the head if data != None: self.size -= 1 return data
class Stack: def __init__(self): self.size = 0 # 1. use array as storage # self.storage = [] # 2. use LinkedList as storage self.storage = LinkedList() def __len__(self): return self.size def push(self, value): # 1. use array as storage # self.size += 1 # self.storage.append(value) # 2. use LinkedList as storage self.size += 1 self.storage.add_to_tail(value) def pop(self): # 1. use array as storage # if self.size == 0: # return None # else: # self.size -= 1 # return self.storage.pop() # 2. use LinkedList as storage if self.size == 0: return None else: self.size -= 1 return self.storage.remove_tail()
class Stack: def __init__(self): self.size = 0 # self.storage = [] self.storage = LinkedList() def __len__(self): # return len(self.storage) return self.size # STACK add to tail & remove from tail def push(self, value): # return self.storage.append(value) self.storage.add_to_tail(value) self.size += 1 def pop(self): # if self.storage: # return self.storage.pop() # else: # return None if self.storage.head: self.size -= 1 return self.storage.remove_tail() else: return None
class Stack: def __init__(self): self.size = 0 # using an array and linked list # self.storage = [] # Using an array self.storage = LinkedList() # using linked list def __len__(self): # return len(self.storage) # using array return self.size def push(self, value): # self.storage.insert(0, value) # inserts value at index 0 self.storage.add_to_tail( value) # run new nude through add_to_tail method self.size += 1 def pop(self): # check that there are values in the list # using array # if self.storage: # return self.storage.pop(0) # removes the value at index 0 and returns that value # else: # # if list is empty return None # return None # using linked list if self.size > 0: self.size -= 1 return self.storage.remove_tail() return None
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: value = self.storage.tail.value self.storage.remove_tail() self.size -= 1 return value def peak(self): if self.size == 0: return None else: value = self.storage.tail.value return value
class Stack(): """Singly-linked list implementation of Stack data structure""" def __init__(self): """Initialize singly-linked list-based Stack class""" self.size = 0 self.storage = LinkedList() def __len__(self): """Return length of Stack class""" return self.size def push(self, value): """Add an element to initialized Stack class""" self.storage.add_to_tail(value) self.size += 1 def pop(self): """Remove most recently added element from Stack class""" if self.__len__() == 0: return None else: self.size -= 1 return self.storage.remove_tail()
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 not self.size: return None ele = self.storage.tail.value current = self.storage.head while current != None: if current.get_next() == self.storage.tail: self.storage.tail = current self.storage.tail.next = None current = current.get_next() self.size -= 1 return ele
class Queue: def __init__(self): self.size = 0 # self.storage = [] self.storage = LinkedList() def __len__(self): return self.size def enqueue(self, value): # self.storage.append(value) self.storage.add_to_tail(value) self.size += 1 def dequeue(self): # if self.size == 0 : # return None # else: # self.size -= 1 # return self.storage.pop(0) if self.size == 0: return None else: self.size -= 1 return self.storage.remove_head()
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def __len__(self): return self.size def enqueue(self, value): # Add value to the end of the storage self.storage.add_to_tail(value) # O(1) # Add 1 to the size of the Queue self.size += 1 # Remove the first value - Queue's function first in first out def dequeue(self): # If the Queue is empty if self.size == 0: return else: # Subtract 1 from the size of the storage self.size -= 1 # Remove the first element return self.storage.remove_head() # O(1)
class Queue: def __init__(self): self.size = 0 # 1. use array as storage # self.storage = [] # 2. use LinkedList as storage self.storage = LinkedList() def __len__(self): return self.size def enqueue(self, value): # 1. use array as storage # self.storage.append(value) # self.size += 1 # 2. use LinkedList as storage self.size += 1 self.storage.add_to_tail(value) def dequeue(self): # 1. use array as storage # if self.size == 0: # return None # else: # value = self.storage[0] # self.storage.remove(value) # self.size -= 1 # return value # 2. use LinkedList as storage if self.size == 0: return None else: self.size -= 1 return self.storage.remove_head()
class Queue: def __init__( self ): #initialize the Queue class that will manage the values of the head (first item in the queue) tail (newest or latest item added to the queue) self.size = 0 self.storage = LinkedList() def __len__( self ): #override the len function to return the size of the queue instantiated in the class return self.size def is_empty( self ): #checks the current length of the queue. This value is changed when elements or queued or dequeued return self.size == 0 def enqueue(self, element): self.storage.add_to_tail(element) self.size += 1 def dequeue(self): if self.is_empty( ): #checks if queue is empty, if it is, this function will not be able to dequeue anything return None result = self.storage.remove_head() self.size -= 1 #it will account for the dequeued element return result
class Stack: def __init__(self): self.size = 0 #for array #self.storage = [] self.storage = LinkedList() def __len__(self): return self.size def push(self, value): # self.storage.append(value)#for array self.size += 1 #for array self.storage.add_to_tail(value) def pop(self): if self.size > 0: self.size = self.size - 1 return self.storage.remove_tail() # stack_instance = Stack() # stack_instance.push(1) # print(stack_instance.__len__()) # stack_instance.push(2) # print(stack_instance.__len__()) # stack_instance.push(2) # stack_instance.push(3) # stack_instance.push(4) # print("size:",stack_instance.size) # print('len: ',stack_instance.__len__()) # stack_instance.pop() # print('len: ',stack_instance.__len__()) # print("size:",stack_instance.size)
class Queue: def __init__(self, init_node=None): if init_node: self.size = 1 else: self.size = 0 self.storage = LinkedList(init_node) def __len__(self): length = 0 if self.storage.head: length = 1 current = self.storage.head while current.next: length += 1 current = current.next self.size = length return length def enqueue(self, value): self.storage.add_to_tail(value) self.size += 1 def dequeue(self): val = self.storage.remove_head() if val: self.size -= 1 return val
class Stack: def __init__(self): self.storage = LinkedList() def __len__(self): return self.storage.length def push(self, value): self.storage.add_to_tail(value) def pop(self): if self.storage.length == 0: return None return self.storage.remove_tail()
class LLQueue: def __init__(self): self.storage = LinkedList() def __len__(self): return self.storage.count def enqueue(self, value): self.storage.add_to_tail(value) def dequeue(self): return self.storage.remove_head()
class Queue: def __init__(self): self.storage = LinkedList() def __len__(self): s = self.storage.length return s def enqueue(self, value): self.storage.add_to_tail(value) def dequeue(self): if self.storage.length == 0: return None v = self.storage.head.get_value() self.storage.remove_head() return v
class Stack: def __init__(self): self.size = 0 self.storage = LinkedList() def __len__(self): return self.storage.getSize() def push(self, value): self.storage.add_to_tail(value) def pop(self): return self.storage.remove_tail()
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList(); def __len__(self): return self.storage.getSize(); def enqueue(self, value): self.storage.add_to_tail(value); def dequeue(self): return self.storage.remove_head();
class Stack: def __init__(self): self.size = 0 self.storage = LinkedList() def __len__(self): length = 0 if self.storage.head is None: return length length = length + 1 next = self.storage.head.get_next() while next: length = length + 1 next = next.get_next() return length def push(self, value): # add to head of linked list prior_head = self.storage.head if prior_head is None: self.storage.add_to_tail(value) else: prior_tail = self.storage.tail self.storage.add_to_tail(value) self.storage.head = self.storage.tail self.storage.head.set_next(prior_head) self.storage.tail = prior_tail self.storage.tail.set_next(None) def pop(self): return self.storage.remove_head() # Array-as-storage version # class Stack: # def __init__(self): # self.size = 0 # self.storage = [] # def __len__(self): # return len(self.storage) # def push(self, value): # self.storage.insert(0, value) # def pop(self): # if len(self.storage) == 0: # return None # return self.storage.pop(0)
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): self.size -= self.size > 0 return self.storage.remove_head()
class LinkedListStack: 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: self.size -= 1 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 __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_head() else: return None
class Stack: def __init__(self): # Starts as a blank linked list self.size = 0 # storage is a linked list self.storage = LinkedList() def __len__(self): # Return the size of the storage return self.size # Add on a value to the end of the array using the LinkedList methods def push(self, value): # Add 1 to the length of the storage self.size += 1 # Use add to tail method to add value to the end of the linked list return self.storage.add_to_tail(value) # Remove the last value from the array - Last in first out def pop(self): # If there is only one element left, it is the head # use remove head method if self.size == 1: # Decrease the size of the storage by 1 self.size -= 1 return self.storage.remove_head() elif self.size > 1: # Decrease the size of the storage by 1 self.size -= 1 return self.storage.remove_tail() else: return