def test_pop_non_empty():
"""Assert first node gets removed and returned."""
from dll import DoublyLinkedList
my_list = DoublyLinkedList()
my_list.insert(4)
my_list.insert(5)
assert my_list.pop() == 5
def sample_dll():
"""Create testing dlls."""
from dll import DoublyLinkedList
one_dll = DoublyLinkedList([1])
empty_dll = DoublyLinkedList()
new_dll = DoublyLinkedList([1, 2, 3, 4, 5])
return one_dll, empty_dll, new_dll
def breadth_first(self, starting_point=None):
"""
This internal method is a generator that will output breadth first
traversal of a binary tree(left child, right child, parent),
one value at a time.
"""
if self.length == 0:
raise IndexError("You can't breadth-first traverse an empty Tree.")
from dll import DoublyLinkedList
unvisited = DoublyLinkedList()
if starting_point is None:
starting_point = self.root
elif self.contains(starting_point) is False:
raise IndexError('Starting point is not in the Tree.')
unvisited.push(starting_point)
visited = []
while unvisited.size() > 0:
current = unvisited.shift()
if current not in visited:
visited.append(current)
if current.left:
unvisited.push(current.left)
if current.right:
unvisited.push(current.right)
yield current.val
def test_DLL_shift(mk_dll):
zeroth = DoublyLinkedList()
with pytest.raises(IndexError):
zeroth.shift()
populated = mk_dll
for x in range(19, -1, -1):
assert populated.shift() == x
class Queue(object):
"""Class implementation of queue.
1. Enqueue: Add new head node.
2. Dequeue: Remove and return tail node value.
3. Peek: Display tail node,
4. Size: Display queue length.
"""
def __init__(self, iterable=None):
"""Instatiate Queue."""
self.dll = DoublyLinkedList(iterable)
def enqueue(self, contents):
"""Add new head node."""
self.dll.push(contents)
def dequeue(self):
"""Remove and return last node value."""
try:
old_tail_node_contents = self.dll.shift()
return old_tail_node_contents
except IndexError:
raise IndexError('Queue is already empty.')
def peek(self):
"""Display but don't remove the contents of tail node."""
try:
return self.dll.tail_node.contents
except AttributeError:
return None
def size(self):
"""Return Queue length."""
return self.dll.length
class Queue(object):
"""Creates a Queue class."""
def __init__(self):
"""Initialization of the queue."""
self._dll = DoublyLinkedList()
self._counter = self._dll._counter
self.head = self._dll.head
self.tail = self._dll.tail
def __len__(self):
"""Overwrite Python built in len function."""
return self._counter
def length(self):
"""Will use DLL counter for length."""
return self._dll._counter
def enqueue(self, data):
"""Add node to queue at head."""
self._dll.push(data)
def dequeue(self):
"""Remove node from queue at tail."""
return self._dll.shift()
def peek(self):
"""Display a value without removing it."""
if self.length == 0:
return None
return self._dll.tail.data
class Queue:
def __init__(self):
self.size = 0
# Why is our DLL a good choice to store our elements?
# it has directional pointers so we know
# where something is in the 'queue'
self.storage = DoublyLinkedList()
def enqueue(self, value):
# take the dll
# run add to tail and pass it value
self.storage.add_to_head(value)
self.size += 1
def dequeue(self):
# check if size > 0
# if yes, dequeue
# take the dll
# run add remove from tail
# decrement size by 1
# if not, return None
if self.size > 0:
self.size -= 1
return self.storage.remove_from_tail()
else:
return None
def len(self):
# return size of queue
return self.size
class RingBuffer:
def __init__(self, capacity):
self.capacity = capacity
self.storage = DoublyLinkedList()
self.marker = None
def append(self, item):
print(f'Marker: {self.marker}')
# check if there is enough room to store item
if len(self.storage) < self.capacity:
self.storage.add_to_tail(item)
print(f'Buffer Size: {len(self.storage)}/{self.capacity}')
# set marker marker to first node input to list
if len(self.storage) == 1:
self.marker = self.storage.head
# reached max capacity
else:
print(
f'Overwriting Marker: {self.marker.value} with New Item: {item}'
)
# overwrite marker value with input item
self.marker.value = item
# change marker to next node if exists
if self.marker.next:
self.marker = self.marker.next
# loops back to the head of list if next is null/reached tail
else:
self.marker = self.storage.head
print(f'Next Marker: {self.marker}')
def get(self):
print(self.storage.get_all())
return self.storage.get_all()
class RingBuffer:
def __init__(self, capacity):
self.capacity = capacity
self.storage = DoublyLinkedList()
self.oldest = None
def append(self, item):
if sef.storage.length == 0:
self.storage.add_to_head(item)
self.oldest = self.storage.head
return
elif self.storage.length < self.capacity:
self.storage.add_to_tail(item)
elif self.storage.length == self.capacity:
if self.oldest = self.storage.head:
self.oldest.value = item
self.oldest = self.oldest.next
elif self.oldest == self.storage.tail:
self.oldest.value = item
self.oldest = self.storage.head
else:
self.oldest.value = item
self.oldest = self.storage.head
class RingBuffer:
def __init__(self, capacity):
'''Because every class needs an "init"'''
self.capacity = capacity # It's the capacity
self.current_node = None # Gotta start somewhere
self.storage = DoublyLinkedList() # Use a DLL to store them in
def append(self, item):
if len(self.storage) < self.capacity: # If there's room in the DLL
self.storage.add_to_tail(item) # Insert the newest node at the end
else:
if self.current_node == None: # If cur is empty
self.storage.head.value = item # Assign it
self.current_node = self.storage.head.next # Update
else:
self.current_node.value = item # Assign it
self.current_node = self.current_node.next # Update
def get(self):
my_list = [] # Make an empty list for the return
current_node = self.storage.head # Get a starting place at the head
while current_node:
my_list.append(current_node.value) # Append
current_node = current_node.next # Move on
return my_list
class RingBuffer:
def __init__(self, capacity):
self.capacity = capacity
self.node = None
self.storage = DoublyLinkedList() #will be stored in
def append(self, item):
if self.storage.length < self.capacity: #check capacity: if space: add item
self.storage.add_to_tail(item) #put item in back
self.node = self.storage.head #make mself head
elif self.storage.length == self.capacity: #if capacity is full need:
self.node.value = item #get the new item
if self.node == self.storage.tail: #if at tail
self.node = self.storage.head #add to dll head
else:
self.node = self.node.next #move nodes down a spot when adaded
def get(self):
storage = [] #list to add nodes to after getting
node = self.storage.head #desingate head
#check for nodes to add, then add nodes to lsit
# while the exist
while node is not None:
storage.append(node.value)
#get next node, then repeat add
node = node.next
#return ist of nodes
return storage
class Queue(object):
"""Queue class. Startrek. Nerds."""
def __init__(self):
"""Init the Queue."""
self.container = DoublyLinkedList()
def enqueue(self, val):
"""Insert into front position."""
self.container.insert(val)
def dequeue(self, val):
"""Remove item in the list."""
self.container.remove(val)
def peek(self):
"""Check the next node in the queue."""
if self.container.tail is None:
return None
return self.container.tail.previous.val
def size(self):
"""Return size of container."""
current = self.container.head
counter = 1
if current is None:
return 0
while current.next is not None:
counter += 1
current = current.next
return counter
class Stack:
def __init__(self):
self.size = 0
# Why is our DLL a good choice to store our elements?
# we will be adding and subtracting based on LIFO
self.storage = DoublyLinkedList()
def push(self, value):
# add to the top of the stack, aka the tail
# increment size by 1
self.size += 1
self.storage.add_to_tail(value)
def pop(self):
# check if size > 0
# if true:
# remove from the top of the stack, aka the tail
# decrement size by 1
# else return None
if self.size > 0:
self.size -= 1
return self.storage.remove_from_tail()
else:
return None
def len(self):
return self.size
def test_DLL_pop(mk_dll):
zeroth = DoublyLinkedList()
with pytest.raises(IndexError):
zeroth.pop()
populated = mk_dll
for twice in range(2):
for x in range(20):
assert populated.pop() == x
def test_remove():
"""Test if selected Node is removed from list."""
from dll import DoublyLinkedList
my_list = DoublyLinkedList()
my_list.insert('last')
my_list.insert('second')
my_list.insert('head')
my_list.remove('second')
assert my_list.head.next.val == 'last'
def __init__(self, initial_text=None):
# the contents of our buffer are stored as a linked list
self.contents = DoublyLinkedList()
"""
if we are passed in initial text as an argument
loop through the string and make linked list nodes
with every letter
"""
if initial_text:
for char in initial_text:
self.contents.add_to_tail(char)
def test_dll_remove():
"""Test for dll remove."""
from dll import DoublyLinkedList
one_dll, empty_dll, new_dll = sample_dll()
new_dll.remove(3)
assert new_dll.length == 4
assert new_dll.head_node.next_node.next_node.contents == 2
assert new_dll.head_node.next_node.next_node.previous_node.contents == 4
try:
new_dll.remove(10)
except NameError:
assert True
new_dll.remove(5)
assert new_dll.head_node.contents == 4
new_dll.remove(1)
assert new_dll.tail_node.contents == 2
empty_dll = DoublyLinkedList()
try:
empty_dll.remove(100)
except NameError:
assert True
one_dll = DoublyLinkedList([1])
one_dll.remove(1)
assert one_dll.head_node is None
assert one_dll.tail_node is None
assert one_dll.length == 0
class Queue(object):
"""First in first out queue structure."""
def __init__(self, iterable=None):
"""Construct queue."""
try:
self._dll = DoublyLinkedList(iterable)
except ValueError:
raise ValueError("Queue optional parameter must be iterable.")
def enqueue(self, val):
"""Add value to the queue."""
self._dll.append(val)
def dequeue(self):
"""Remove item from the queue and returns an error if queue empty."""
try:
return self._dll.pop()
except:
raise IndexError('Cannot dequeue from an empty queue.')
def peek(self):
"""Return the next value in the queue without dequeueing it. If the."""
"""queue is empty, returns None."""
return self.head.val if self.head else None
def size(self):
"""Return the size of the queue, if empty return 0."""
return self._dll._length
def clear(self):
"""Empty queue."""
self._dll.head = None
self._dll.tail = None
self._dll._length = 0
def __len__(self):
"""Return length of queue."""
return self.size()
@property
def head(self):
"""Read only head property."""
return self._dll.head
@property
def tail(self):
"""Read only tail property."""
return self._dll.tail
class Queue:
def __init__(self):
self.size = 0
# using DLL for constant time enqueue and dequeue
self.dll = DoublyLinkedList()
def __len__(self):
return len(self.dll)
def enqueue(self, item):
self.dll.add_to_tail(item)
def dequeue(self):
return self.dll.remove_from_head()
def len(self):
return len(self)
class LRUCache:
"""
Our LRUCache class keeps track of the max number of nodes it
can hold, the current number of nodes it is holding, a doubly-
linked list that holds the key-value entries in the correct
order, as well as a storage dict that provides fast access
to every node stored in the cache.
"""
def __init__(self, limit=10):
self.limit = limit
self.size = 0
self.order = DoublyLinkedList()
# self.order = list()
self.storage = dict()
"""
Retrieves the value associated with the given key. Also
needs to move the key-value pair to the end of the order
such that the pair is considered most-recently used.
Returns the value associated with the key or None if the
key-value pair doesn't exist in the cache.
"""
def get(self, key):
if key not in self.storage:
return None
else:
node = self.storage[key]
self.order.move_to_end(node)
return node.value[1]
"""
Adds the given key-value pair to the cache. The newly-
added pair should be considered the most-recently used
entry in the cache. If the cache is already at max capacity
before this entry is added, then the oldest entry in the
cache needs to be removed to make room. Additionally, in the
case that the key already exists in the cache, we simply
want to overwrite the old value associated with the key with
the newly-specified value.
"""
def set(self, key, value):
if key in self.storage:
node = self.storage[key]
node.value = (key, value)
self.order.move_to_end(node)
return
if len(self.order) == self.limit:
evicted = self.order.head.value[0]
del self.storage[evicted]
self.order.remove_from_head()
self.order.add_to_tail((key, value))
self.storage[key] = self.order.tail
def test_shift():
"""Assert shift works on non empty list."""
from dll import DoublyLinkedList
my_list = DoublyLinkedList()
my_list.insert(1)
my_list.insert(2)
my_list.insert(3)
assert my_list.shift() == 1
class Queue:
def __init__(self):
self.size = 0
self.storage = DoublyLinkedList()
def enqueue(self, value):
self.size += 1
self.storage.add_to_tail(value)
def dequeue(self):
value = self.storage.remove_from_head()
if value is not None:
self.size -= 1
return value
def len(self):
return self.size
class LRUCache:
def __init__(self, limit=10):
self.limit = limit
self.length = 0
self.dll = DoublyLinkedList()
"""
Retrieves the value associated with the given key. Also
needs to move the key-value pair to the top of the order
such that the pair is considered most-recently used.
Returns the value associated with the key or None if the
key-value pair doesn't exist in the cache.
"""
def get(self, key):
found = self.dll.search(key)
if found is None:
return None
self.dll.move_to_front(found)
return found.value[key]
"""
Adds the given key-value pair to the cache. The newly-
added pair should be considered the most-recently used
entry in the cache. If the cache is already at max capacity
before this entry is added, then the oldest entry in the
cache needs to be removed to make room. Additionally, in the
case that the key already exists in the cache, we simply
want to overwrite the old value associated with the key with
the newly-specified value.
"""
def set(self, key, value):
found = self.dll.search(key)
if found is not None:
found.value[key] = value
self.dll.move_to_front(found)
else:
if self.length == self.limit:
self.dll.remove_from_tail()
else:
self.length += 1
self.dll.add_to_head({key: value})
def test_insert_on_non_emtpy_list():
"""Assert insert on non-empty list works."""
from dll import DoublyLinkedList
my_list = DoublyLinkedList()
my_list.insert(4)
my_list.insert('Diana')
assert my_list.head.val == 'Diana'
def test_assert_previous():
"""Assert second node points to its previous."""
from dll import DoublyLinkedList
my_list = DoublyLinkedList()
my_list.insert('Daniel')
my_list.insert('Diana')
assert my_list.head.val == 'Diana'
def test_pop_single_item_list():
"""Test pop on single item list."""
from dll import DoublyLinkedList
my_list = DoublyLinkedList()
my_list.insert(4)
my_list.pop()
assert my_list.head is None
def test_append_non_empty():
"""Assert node gets appended to the end of the lsit."""
from dll import DoublyLinkedList
my_list = DoublyLinkedList()
my_list.insert(4)
my_list.append(8)
assert my_list.tail.val == 8
def test_tail():
"""Assert the last node is the tail."""
from dll import DoublyLinkedList
my_list = DoublyLinkedList()
my_list.insert(4)
my_list.insert(5)
my_list.insert(6)
assert my_list.tail.val == 4
def test_DLL_rm(mk_dll):
zeroth = DoublyLinkedList()
with pytest.raises(IndexError):
zeroth.remove(3)
populated = mk_dll
# Remove from the head
assert populated.head.data == 0
populated.remove(0)
assert populated.head.data == 1
# Remove from the tail
assert populated.tail.data == 19
populated.remove(19)
assert populated.tail.data == 18
# Remove from the middle
current = populated.head
for a in range(5):
current = current.next
the_nexts_value = current.next.data
populated.remove(the_nexts_value)
assert the_nexts_value + 1 == current.next.data
# Try to remove a value that isn't there
with pytest.raises(ValueError):
populated.remove('not there')
class Deque(object):
"""Deque implements a simple Python deque data structure."""
def __init__(self, iterable=None):
"""Init deque, iterate through data if provided as an argument."""
self.dll = DoublyLinkedList(iterable)
def append(self, data):
"""Append a node containing data to the head(end) of the deque."""
self.dll.push(data)
def appendleft(self, data):
"""Append a node containing data to the tail(front) of the deque."""
self.dll.append(data)
def pop(self):
"""Remove a value from the head(end) of the deque and return it.
Will raise an exception if the deque is empty."""
try:
return self.dll.pop()
except AttributeError:
raise IndexError("The deque is empty.")
def popleft(self):
"""Remove a value from the tail(front) of the deque and return it.
Will raise an exception if the deque is empty."""
try:
return self.dll.shift()
except AttributeError:
raise IndexError("The deque is empty.")
def peek(self):
"""Returns the value of the head(end) of the deque.
Returns None if the deque is empty."""
if self.dll.head is None:
return None
return self.dll.head.data
def peekleft(self):
"""Returns a value from the tail(front) of the deque.
Returns None if the deque is empty."""
if self.dll.tail is None:
return None
return self.dll.tail.data
def size(self):
"""Returns the count of nodes in the queue, 0 if empty."""
count = 0
current = self.dll.head
while current is not None:
count += 1
current = current._next
return count
class Deque(object):
"""Deque class."""
def __init__(self):
"""Initilizer of deque class."""
self.container = DoublyLinkedList()
def append_left(self, val):
"""Append val to the head of the list."""
self.container.insert(val)
def append(self, val):
"""Append val to the tail of the list."""
self.container.append(val)
def pop(self):
"""Return and remove head from the list."""
self.container.shift()
def pop_left(self):
"""Remove head of deque and return that value."""
self.container.pop()
def peek(self):
"""Check the next node in the deque."""
if self.container.tail is None:
return None
return self.container.tail.val
def peek_left(self):
"""Return the tail of the deque."""
if self.container.head is None:
return None
return self.container.head.val
def size(self):
"""Return the size of the deque."""
current = self.container.head
counter = 1
if current is None:
return 0
while current.next is not None:
counter += 1
current = current.next
return counter
def test_insert_on_empty_list():
"""Assert insert works."""
from dll import DoublyLinkedList
my_list = DoublyLinkedList()
my_list.insert(4)
assert my_list.head.val == 4
def __init__(self):
"""Initilizer of deque class."""
self.container = DoublyLinkedList()
def test_shift_empty():
"""Assert shift works on empty list."""
from dll import DoublyLinkedList
my_list = DoublyLinkedList()
with pytest.raises(IndexError):
my_list.shift()
def test_remove_empty():
"""Assert remove works on empty list."""
from dll import DoublyLinkedList
my_list = DoublyLinkedList()
with pytest.raises(AttributeError):
my_list.remove('chicken')
def test_pop_empty():
from dll import DoublyLinkedList
my_list = DoublyLinkedList()
with pytest.raises(IndexError):
my_list.pop()
def test_append_empty():
"""Assert node gets appended to empty list."""
from dll import DoublyLinkedList
my_list = DoublyLinkedList()
my_list.append(4)
assert my_list.tail.val == 4