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)