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
