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_head(value)
self.size +=1
def pop(self):
if self.size <= 0:
return None
else:
val = self.storage.head.get_value()
self.storage.remove_head()
self.size -= 1
return val
class Stack:
'''
A stack implemented with a linked list
'''
def __init__(self):
self.size = 0
self.storage = LinkedList()
def __len__(self):
'''
Returns the number of elements in the stack
'''
return self.size
def push(self, value):
'''
Adds a value to the top of the stack
'''
self.storage.add_to_head(value)
self.size += 1
def pop(self):
'''
removes and returns the element at the top of the stack
'''
if self.size == 0:
return None
self.size -= 1
return self.storage.remove_head()
class Stack:
"""Linked list as the underlying storage structure"""
def __init__(self):
self.size = 0
self.storage = LinkedList()
def __len__(self):
return self.size
def push(self, value):
#self.size += 1
#return self.storage.add_to_tail(value)
self.storage.add_to_head(value)
self.size += 1
def pop(self):
#!= : this mean there is no elements in the list
# if self.size != 0:
# # -= : removing one element at a time.
# self.size -= 1
# return self.storage.remove_tail()
if self.size == 0:
return None
self.size -= 1
return self.storage.remove_head()
class Queue:
def __init__(self):
self.size = 0
# self.storage = np.array([])
self.storage = LinkedList(None)
def __len__(self):
return self.size
def enqueue(self, value):
# When you form a queue you add to the head
# self.storage = np.insert(self.storage, 0, value)
self.storage.add_to_head(value)
self.size += 1
return
def dequeue(self):
# When you leave the queue you leave from the tail
if self.size == 0:
return None
else:
# delvalue = self.storage[-1]
# self.storage = self.storage[:-1]
# self.size -= 1
# return delvalue
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 = LinkedList()
def isEmpty(self):
return self.size == 0
# len performance: O(1)
def __len__(self):
return self.size
# push performance: O(1)
def push(self, value):
self.storage.add_to_head(value)
self.size += 1
# pop performance: O(1)
def pop(self):
if self.size == 0:
return None
else:
self.size -= 1
return self.storage.remove_head()
# 3. In terms of the implementation, both Stacks are nearly identical with only the
# method names differing. In terms of performance, the push and pop methods for both
# implementations are O(1). Note that the LinkedList's remove_tail method has a
# performance of O(n). So in order for the LinkedList implementation to acheive a
# performance of O(1), the Stack must be implemented so that 'head' of the LinkedList
# represents the 'top' of the Stack. This is different from the array implementation
# where last index in the array represents the 'top' of the Stack.
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_head(value)
self.size += 1
return self.storage
def pop(self):
if self.size == 0:
return None
else:
node = self.storage.remove_head()
self.size -= 1
return node
# if __name__ == '__main__':
# Stack.main()
# stack = Stack()
# print(len(stack))
# print(stack.push(4))
# print(stack.push(5))
# print(stack.push(6))
# print(stack.pop())
# print(len(stack))
class QueueLL:
def __init__(self):
self.size = 0
self.storage = LinkedList()
def enqueue(self, value):
self.storage.add_to_head(value)
def dequeue(self):
self.storage.remove_tail()
class StackLL:
def __init__(self):
self.size = 0
self.storage = LinkedList()
def push(self, value):
self.storage.add_to_head(value)
def pop(self):
if len(self.storage) == 0:
return None
self.storage.remove_head()
class LLCoolStack:
def __init__(self):
self.storage = LinkedList()
def __len__(self):
return self.storage.count
def push(self, value):
self.storage.add_to_head(value)
def pop(self):
return self.storage.remove_head()
class Stack:
def __init__(self):
self.size = 0
self.storage = LinkedList()
def __len__(self):
return self.storage.get_length()
def push(self, value):
self.storage.add_to_head(value)
def pop(self):
return self.storage.remove_head()
class Stack:
def __init__(self):
self.__storage = LinkedList()
def __len__(self):
return self.size
def push(self, value):
self.__storage.add_to_head(value)
def pop(self):
return self.__storage.remove_head()
@property
def size(self) -> int:
return len(self.__storage)
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_head(value)
self.size = self.storage.length
def dequeue(self):
removed = self.storage.remove_tail()
self.size = self.storage.length
return removed
class StackL:
def __init__(self):
self.size = 0
self.storage = LinkedList()
def __len__(self):
return self.size
def push(self, value):
self.storage.add_to_head(value)
self.size += 1
def pop(self):
if self.size == 0:
return None
self.size -= 1
return self.storage.remove_head()
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_head(value)
self.size += 1
def pop(self):
removed = self.storage.remove_head()
if removed is not None:
self.size -= 1
return removed
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_head(value)
self.size += 1
def dequeue(self):
removed = self.storage.remove_tail()
if removed is not None:
self.size -= 1
return removed
class Stack:
"""Object-oriented implementation of Stack class with Node and
LinkedList"""
def __init__(self):
self.size = 0
self.storage = LinkedList()
def __len__(self):
count = 0
current = self.storage.head
# loop through to count "heads"
while current:
current = current.get_next()
count += 1
self.size = count
return count
def push(self, value):
"""Adds an item to the top of the stack"""
self.storage.add_to_head(value) #O(1)
count = 0
current = self.storage.head
# loop through to count "heads"
while current:
current = current.get_next()
count += 1
self.size = count
def pop(self):
"""Removes and returns the element at the top of the stack"""
# if empty
if self.size == 0:
return None
else:
top = self.storage.head.get_value()
self.storage.remove_head() #O(1)
return top
count = 0
current = self.storage.head
# loop through to count "heads"
while current:
current = current.get_next()
count += 1
self.size = count
class Stack:
def __init__(self):
self.size = 0
self.storage = LinkedList()
def __len__(self):
return self.size
def push(self, value):
self.size += 1
self.storage.add_to_head(value)
def pop(self):
if not self.storage.head:
self.size ==0
else:
self.size -= 1
return self.storage.remove_head()
class Stack:
def __init__(self):
self.size = 0
self.items = LinkedList()
def __len__(self):
return self.size
def push(self, value):
self.size += 1
self.items.add_to_head(value)
def pop(self):
if self.size == 0:
return None
else:
self.size -= 1
return self.items.remove_head()
class Stack: #LL-based implementation
# New elements added to head, popped off of head
def __init__(self):
self.size = 0
self.storage = LinkedList()
def __len__(self):
return self.size
def push(self, value):
self.size += 1
self.storage.add_to_head(value)
def pop(self):
if self.size == 0: #self.storage.head is None and self.storage.tail is None:
return None
else:
self.size -= 1
return self.storage.remove_head()
class Stack:
def __init__(self):
self.size = 0
self.storage = LinkedList()
def __len__(self):
current_node = self.storage.head
length = 0
while current_node:
length += 1
current_node = current_node.next_node
return length
def push(self, value):
self.storage.add_to_head(value)
def pop(self):
return self.storage.remove_head()
class Stack:
def __init__(self):
self.size = 0
self.storage = LinkedList()
def __str__(self):
return f'{self.size} : {self.storage}'
def __len__(self):
return self.size
def push(self, value):
self.storage.add_to_head(value)
self.size += 1
def pop(self):
if self.size > 0:
self.size -= 1
return self.storage.remove_head()
return None
# testing_list = Stack()
# print(testing_list, "Empty")
# testing_list.push(100)
# print(testing_list.__len__, "length")
# print(testing_list, "First add")
# testing_list.push(101)
# print(testing_list.__len__, "length")
# print(testing_list, "Second add")
# testing_list.push(105)
# print(testing_list.__len__, "length")
# print(testing_list, "third add")
# testing_list.pop()
# print(testing_list.__len__, "length")
# print(testing_list, "pop 1")
# testing_list.pop()
# print(testing_list.__len__, "length")
# print(testing_list, "pop 2")
# testing_list.pop()
# print(testing_list.__len__, "length")
# print(testing_list, "pop 3")
# print(testing_list, "list")
class Stack:
def __init__(self):
self.size = 0
self.storage = LinkedList()
def __len__(self):
return self.size
def push(self, value):
self.size += 1
self.storage.add_to_head(value)
def pop(self):
if self.size:
self.size -= 1
removed_head_val = self.storage.remove_head()
return removed_head_val
else:
return None
class Queue:
def __init__(self):
self.size = 0
self.storage = LinkedList()
def __len__(self):
return self.size
def enqueue(self, value):
# Increase size by 1
self.size = self.size + 1
# Push new value into the back of the queue
self.storage.add_to_head(value)
return None
def dequeue(self):
# Check for 0 to avoid a negative size
if self.size > 0:
self.size = self.size - 1
return self.storage.remove_tail()
class StackQueue:
def __init__(self):
self.size = 0
self.storage = LinkedList()
def __len__(self):
return self.size
def push(self, value):
self.storage.add_to_head(value)
self.size = self.size + 1
return value
def pop(self):
if self.size >= 1:
val = self.storage.remove_head()
self.size = self.size - 1
return val
else:
return None
class Stack:
def __init__(self):
self.size = 0
self.storage = LinkedList()
def __len__(self):
return self.size
@property
def isEmpty(self):
return self.size == 0
def push(self, value):
self.storage.add_to_head(value)
self.size += 1
def pop(self):
if self.size:
self.size -= 1
return self.storage.remove_head()
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_head(value)
self.size += 1
def pop(self):
try:
val = self.storage.head.value
self.storage.remove_head()
self.size -= 1
return val
except:
return None
class Stack: # In a stack, a new element is added at one end and an element is removed from that end only.
def __init__(self):
self.size = 0
self.storage = LinkedList()
def __len__(self):
return self.size
def push(self, value):
self.size += 1
self.storage.add_to_head(value)
def pop(self):
if self.size > 0:
self.size -= 1
return self.storage.remove_head()
else:
return None
def len(self):
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.size += 1
self.storage.add_to_head(value)
def pop(self):
if self.size > 0:
self.size -= 1
return self.storage.remove_from_head()
# 3.
# The difference between linked lists and array methods are that the array methods are already built in parts of the storage list.
# We can use these instead of writing out our own in a linked list class, and we can reference indeces of the array whereas in linked
# lists we cannot. Additionally when implementing linked lists with stacks, it seems we need to have an additional 'Remove from tail'
# method in order to properly pop() in the way that is expected with a stack.
class Queue:
def __init__(self):
self.size = 0
self.storage = LinkedList()
def __len__(self):
return len(self.storage)
def enqueue(self, value):
return self.storage.add_to_head(value)
def dequeue(self):
if len(self.storage) == 0:
return None
return self.storage.remove_tail()
class Stack:
def __init__(self):
self.size = 0
self.storage = LinkedList()
def isEmpty(self):
return self.size == 0
# len performance: O(1)
def __len__(self):
return self.size
# push performance: O(1)
def push(self, value):
self.storage.add_to_head(value)
self.size += 1
# pop performance: O(1)
def pop(self):
if self.size == 0:
return None
else:
self.size -= 1
return self.storage.remove_head()
