class Stack:
def __init__(self):
self.items = LinkedList()
def push(self, value):
"""
Adds the value to the back of the LinkedList
:param value: the value to be added
"""
self.items.add(value)
def pop(self):
"""
Removes the value at the tail
:return: the value of the item removed
"""
if self.items.tail is None:
return None
value = self.items.tail.value
self.items.remove(value)
return value
def peek(self):
"""
:returns: the value of the item at the tail
"""
if not self.items.tail:
return None
return self.items.tail.value
def test_3():
new_list = LinkedList()
new_list.insert('a')
new_list.insert('b')
actual = new_list.head.data
expected = 'a'
assert actual == expected
class Stack:
def __init__(self):
self.list = LinkedList()
# Get the size of the stack
def size(self) -> int:
return self.list.size()
# Check if the stack is empty
def isEmpty(self) -> bool:
return self.size() == 0
# Get the value of an item from the top of a stack
def peek(self) -> object:
if (self.isEmpty()):
raise Exception('Cannot perform peek on an empty list')
return self.list.peekLast()
# Remove an item from the top of a stack
def pop(self) -> LinkedList.Node:
if (self.isEmpty()):
raise Exception('Cannot perform poll on an empty list')
return self.list.removeLast()
# Add item to the back of the stack
def push(self, item: object):
if item is None: return Exception('Cannot add a None object')
self.list.addLast(item)
def test_same_kth():
node = Node(0)
link = LinkedList(node)
link.kthFromEnd(10)
actual = 4
expected = 4
assert actual == expected
def test_insert_2(): # 6
ll = LinkedList()
ll.append(0)
ll.append('a')
ll.append(True)
ll.insert(12)
assert ll.head.value == 12
class StackList:
def __init__(self):
self._stack = LinkedList()
self._length = 0
def show(self):
if self.is_empty():
return None
return self._stack.tail
def put(self, item):
self._stack.append(item)
self._length += 1
def pop(self):
if self.is_empty():
raise Exception("stack underflow")
self._length -= 1
return self._stack.pop()
def is_empty(self):
return self._length == 0
@property
def stack(self):
return self._stack
@property
def length(self):
return self._length
def test_same_length():
ll = LinkedList()
ll.insert(1)
return ll
actual = from_end(1)
expected = 1
assert actual == expected
def test_neg():
node = Node(0)
link = LinkedList(node)
link.kthFromEnd(10)
actual = 'negative number given'
expected = 'negative number given'
assert actual == expected
def test_zip_list():
list_one = LinkedList(["a", "b", "c", "d"])
list_two = LinkedList(["1", "2", "3", "4"])
zipped_list = zip_list(list_one, list_two)
actual = zipped_list.value_list()
expected = ["a", "1", "b", "2", "c", "3", "d", "4"]
assert expected == actual
def test_insert_3(): # 7
ll = LinkedList()
ll.append(0)
ll.append('a')
ll.append(True)
ll.insert(12)
assert ll.head.next.next.value == 'a'
def test_add_one_item(self):
linked_list = LinkedList()
linked_list.add(1)
# assert that the item we inserted is at the head
self.assertEqual(linked_list.head.value, 1)
# assert that when only one item is in the list the head and the tail are the same
self.assertEqual(linked_list.tail.value, 1)
def starter_fruit():
ll = LinkedList()
ll.insert("apples")
ll.insert("bananas")
ll.insert("cantaloupes")
ll.insert("d'Anjou pears")
return ll
def test_insert_one():
mammals = LinkedList()
mammals.insert('bear')
expected = 'bear'
actual = mammals.head.value
assert actual == expected
class QueueList:
def __init__(self):
self._queue = LinkedList()
self._length = 0
def is_empty(self):
return self._length == 0
@property
def queue(self):
if self.is_empty():
return None
return self._queue
@property
def head(self):
if self.is_empty():
return None
return self._queue[0]
def put(self, item):
self._queue.append(item)
self._length += 1
def pop_left(self):
self._length -= 1
return self._queue.pop(0)
def display(self):
if self.is_empty():
print("Circular queue is empty")
else:
print("Circular queue:", self._queue)
def __init__(self, values=(), max_size=100):
oversize = 0
if len(values
) > max_size: # will throw type error if max_size is not int
oversize = len(values)
values = values[0:max_size]
self._ll = LinkedList(values)
#super().__init__(values)
# but we need to reverse list b/c linkedlist constructs from values by putting value at index 0 at head of list
self._ll.reverse()
if not isinstance(max_size, int):
raise TypeError(
"The given max_size {} is not valid. max_size must be an integer"
.format(max_size))
# throw ValueError if max_size is negative
if max_size < 0:
raise ValueError(
"The given max_size {} is not valid. max_size must be an integer"
.format(max_size))
self.max_size = max_size
if oversize > 0:
raise StackOverflowError(
"This stack has a maximum size limit of {0}. Number of intitial values {1} "
"exceeds this limit. Only first {0} values have been pushed".
format(max_size, oversize))
class Queue:
def __init__(self):
"""
Initialize the Queue with an empty LinkedList
"""
self.items = LinkedList()
def is_empty(self):
"""
:returns: True if the LinkedList is empty anf False if it isn't
"""
return self.items.head is None
def enqueue(self, value):
"""
Adds the value to the back of the LinkedList
:param value: the value to be added
"""
self.items.add(value)
def dequeue(self):
"""
Removes the value at the head
:return: the value of the item at the head
"""
value = self.items.head.value
self.items.remove(value)
return value
def peek(self):
"""
:returns: the value of the item at the head
"""
return self.items.head.value
def test_head_property_will_properly_point_to_the_first_node_in_the_linked_list():
newList = LinkedList()
newList.insert("Two")
newList.insert("One")
expected = "One"
actual = newList.headVal.nodeVal
assert expected == actual
def test_2():
new_list = LinkedList()
new_list.insert('a')
new_list.insert('b')
actual = new_list.__str__()
expected = '{ a } -> { b } -> -> NULL'
assert actual == expected
def test_length():
node = Node(0)
link = LinkedList(node)
link.kthFromEnd(10)
actual = 'number is greater than the length of list.'
expected = 'number is greater than the length of list.'
assert actual == expected
def test_three():
ll2 = LinkedList()
ll2.insert("banana")
ll2.insert("orange")
actual = ll2.head.value
expected = "orange"
assert actual == expected
def test_merging_both_empty(): # both empty lst_one = LinkedList() lst_two = LinkedList() merging=LinkedList() expeted=merging.zipLists(lst_one,lst_two) actual='' assert expeted==actual
def test_linked_list_size_1():
node1 = Node(5)
linked_list = LinkedList()
linked_list.head = node1
actual = linked_list.kth(0)
expected = 5
assert actual == expected
def test_add_five_elements_to_end_and_iterate_linked_list(self):
linked_list = LinkedList()
langs = ['python', 'java', 'ruby', 'php', 'go']
for lang in langs:
linked_list.add_last(lang)
self.assertEqual(len(langs), linked_list.size())
for node in linked_list:
self.assertIn(node.item, langs)
def setup(self):
e1 = Element(1)
e2 = Element(2)
e3 = Element(3)
self.ll = LinkedList(e1)
self.ll.append(e2)
self.ll.append(e3)
def test_edge_cases():
ll_one = LinkedList(["a", "b", "c", "d", "q"])
ll_two = LinkedList(["1", "2", "3"])
zipped = zip_lists(ll_one, ll_two)
expected = ["a", "1", "b", "2", "c", "3", "d", "q"]
while zipped:
assert zipped.value == expected.pop(0)
zipped = zipped.next
def test_delete_unexistent_item(self):
linked_list = LinkedList()
linked_list.insert("Flash")
linked_list.insert("Arrow")
with self.assertRaises(ValueError):
linked_list.delete("Harrison Wells")
def test_includes_method():
lst_two = LinkedList()
lst_two.insert('apples')
lst_two.insert('pickles')
lst_two.insert('chips')
assert lst_two.includes('pickles') == True
assert lst_two.includes('whales') == False
def test2():
ll = LinkedList()
ll.append(1)
ll.append(2)
ll.append(3)
ll.insertBefore(2, 20)
ll.insertBefore(20, 44)
assert ll.head.next.value == 44
def test_remove_from_tail(self):
linked_list = LinkedList()
linked_list.add(2)
linked_list.add(4)
linked_list.add(25)
linked_list.add(20)
linked_list.add(12)
self.assertEqual(linked_list.remove(12), True)
self.assertEqual(linked_list.walk(), [2, 4, 25, 20])
def test_remove_from_middle(self):
linked_list = LinkedList()
linked_list.add(2)
linked_list.add(4)
linked_list.add(25)
linked_list.add(20)
linked_list.add(12)
self.assertEqual(linked_list.remove(25), True)
self.assertEqual(linked_list.walk(), [2, 4, 20, 12])
def test_remove_item_not_in_list(self):
linked_list = LinkedList()
linked_list.add(2)
linked_list.add(4)
linked_list.add(25)
linked_list.add(20)
linked_list.add(12)
self.assertEqual(linked_list.remove(0), False)
self.assertEqual(linked_list.walk(), [2, 4, 25, 20, 12])
def test_insert_at_tail(self):
linked_list = LinkedList()
linked_list.insert_at_tail("Deadpool")
linked_list.insert_at_tail("Green Lantern")
self.assertEqual(linked_list.head.get_data(), "Deadpool")
next_node = linked_list.head.get_next()
self.assertEqual(next_node.get_data(), "Green Lantern")
def test_insert_two_items(self):
linked_list = LinkedList()
linked_list.insert("Ironman")
linked_list.insert("Captain America")
self.assertEqual(linked_list.head.get_data(), "Captain America")
next_head = linked_list.head.get_next()
self.assertEqual(next_head.get_data(), "Ironman")
def test_show(self):
linked_list = LinkedList()
linked_list.insert("Aquaman")
linked_list.insert("Wonder Woman")
linked_list.insert("Green Lantern")
expected = "Green Lantern => Wonder Woman => Aquaman"
self.assertEqual(linked_list.show(), expected)
def test_search_unexistent_item(self):
linked_list = LinkedList()
linked_list.insert("Spiderman")
linked_list.insert("Hulk")
with self.assertRaises(ValueError):
node_found = linked_list.search("Daredevil")
def test_next_node(self):
linked_list = LinkedList()
linked_list.insert("Clark Kent")
linked_list.insert("Bruce Wayne")
linked_list.insert("Peter Parker")
self.assertEqual(linked_list.head.get_data(), "Peter Parker")
next_head = linked_list.head.get_next()
self.assertEqual(next_head.get_data(), "Bruce Wayne")
last_node = next_head.get_next()
self.assertEqual(last_node.get_data(), "Clark Kent")
def test_search(self):
linked_list = LinkedList()
linked_list.insert("Batman")
linked_list.insert("Superman")
linked_list.insert("Deadpool")
node = linked_list.search("Superman")
self.assertNotEqual(node, None)
self.assertEqual(node.get_data(), "Superman")
class Stack(object):
def __init__(self):
self.stack = LinkedList()
def push(self, element):
self.stack.append(element)
def pop(self):
return self.stack.pop()
def peek(self):
if self.stack.length():
return self.stack.retrieve(self.stack.length() - 1)
else:
raise Exception("List is Empty")
def isEmpty(self):
return not self.stack.length()
def size(self):
return self.stack.length()
def test_search_in_empty_list(self):
linked_list = LinkedList()
with self.assertRaises(ValueError):
linked_list.search("Oliver Queen")
def test_delete_empty_list(self):
linked_list = LinkedList()
with self.assertRaises(ValueError):
linked_list.delete("Barry Allen")
def setUp(self):
self.list = LinkedList()
class TestLinkedList(unittest.TestCase):
def setUp(self):
self.list = LinkedList()
def tearDown(self):
self.list = None
def test_insert(self):
self.list.insert("David")
self.assertTrue(self.list.head.get_data() == "David")
self.assertTrue(self.list.head.get_next() is None)
def test_insert_two(self):
self.list.insert("David")
self.list.insert("Thomas")
self.assertTrue(self.list.head.get_data() == "Thomas")
head_next = self.list.head.get_next()
self.assertTrue(head_next.get_data() == "David")
def test_nextNode(self):
self.list.insert("Jacob")
self.list.insert("Pallymay")
self.list.insert("Rasmus")
self.assertTrue(self.list.head.get_data() == "Rasmus")
head_next = self.list.head.get_next()
self.assertTrue(head_next.get_data() == "Pallymay")
last = head_next.get_next()
self.assertTrue(last.get_data() == "Jacob")
def test_positive_search(self):
self.list.insert("Jacob")
self.list.insert("Pallymay")
self.list.insert("Rasmus")
found = self.list.search("Jacob")
self.assertTrue(found.get_data() == "Jacob")
found = self.list.search("Pallymay")
self.assertTrue(found.get_data() == "Pallymay")
found = self.list.search("Jacob")
self.assertTrue(found.get_data() == "Jacob")
def test_searchNone(self):
self.list.insert("Jacob")
self.list.insert("Pallymay")
# make sure reg search works
found = self.list.search("Jacob")
self.assertTrue(found.get_data() == "Jacob")
with self.assertRaises(ValueError):
self.list.search("Vincent")
def test_delete(self):
self.list.insert("Jacob")
self.list.insert("Pallymay")
self.list.insert("Rasmus")
# Delete the list head
self.list.delete("Rasmus")
self.assertTrue(self.list.head.get_data() == "Pallymay")
# Delete the list tail
self.list.delete("Jacob")
self.assertTrue(self.list.head.get_next() is None)
def test_delete_value_not_in_list(self):
self.list.insert("Jacob")
self.list.insert("Pallymay")
self.list.insert("Rasmus")
with self.assertRaises(ValueError):
self.list.delete("Sunny")
def test_delete_empty_list(self):
with self.assertRaises(ValueError):
self.list.delete("Sunny")
def test_delete_next_reassignment(self):
self.list.insert("Jacob")
self.list.insert("Cid")
self.list.insert("Pallymay")
self.list.insert("Rasmus")
self.list.delete("Pallymay")
self.list.delete("Cid")
self.assertTrue(self.list.head.next_node.get_data() == "Jacob")
def test_delete_next_and_reassignment(self):
linked_list = LinkedList()
linked_list.insert("Tony Stark")
linked_list.insert("Thor")
linked_list.insert("Bruce Banner")
linked_list.insert("Clint Barton")
linked_list.delete("Clint Barton")
linked_list.delete("Thor")
self.assertEqual(linked_list.head.get_data(), "Bruce Banner")
def __init__(self): self.stack = LinkedList()
def test_delete(self):
linked_list = LinkedList()
linked_list.insert("Darth Vader")
linked_list.insert("R2-D2")
linked_list.insert("Luke Skywalker")
linked_list.delete("Luke Skywalker")
self.assertEqual(linked_list.head.get_data(), "R2-D2")
linked_list.delete("R2-D2")
self.assertEqual(linked_list.head.get_next(), None)
def test_insert(self):
linked_list = LinkedList()
linked_list.insert("Matheus")
self.assertEqual(linked_list.head.get_data(), "Matheus")
self.assertEqual(linked_list.head.get_next(), None)
