def test_pop_removes_last_item(self): l1 = LinkedList([1, 2, 3]) elem = l1.pop(2) self.assertEqual(elem, 3) self.assertEqual(l1.count(), 2) self.assertEqual(l1, LinkedList([1, 2]))
def test_remove_one_node(): """Test to remove one node.""" from linked_list import LinkedList my_list = LinkedList() my_list.insert('a') my_list.remove('a') assert my_list.head is None
def test_number_averaging_normal(self): self.assertEquals(number_average([0.0, 1.0, 2.0, 3, 4, 5], simple_func), 2.5) self.assertEquals(number_average([0.0, 1.0, 2.0, 3, 4, 5], simple_func), 2.5) self.assertEquals(number_average([0, 1, 2, 3, 4, 11], simple_func), 3.5) list = LinkedList() list.add_last(0) self.assertEquals(number_average(list, simple_func), 0)
def test_linkedlist_remove_head(): """Test LinkedList.remove for proper last Node removal.""" from linked_list import LinkedList, Node input_ = "a b c".split() linked_list_instance = LinkedList(input_) linked_list_instance.remove(Node('a')) assert linked_list_instance.tail.pointer.pointer is None
def test_add_adds_to_end(self): llist = LinkedList() node = Node(1) node2 = Node(2) llist.add(node) llist.add(node2) self.assertEqual(llist.head, node)
def test_linkedlist_insert_empty(): """Test LinkedList.insert from an empty list.""" from linked_list import LinkedList input_ = [] linked_list_instance = LinkedList(input_) linked_list_instance.insert('a') assert linked_list_instance.size() == 1
def test_linkedlist_insert_string(): """Test LinkeList.insert for tail addition to Node list.""" from linked_list import LinkedList input_ = [1, 2, 3] linked_list_instance = LinkedList(input_) linked_list_instance.insert("Nadia") assert linked_list_instance.tail.pointer.pointer.pointer.value == "Nadia"
def test_linkedlist_pop_empty(): """Test LinkedList.pop from an empty list.""" from linked_list import LinkedList input_ = [] linked_list_instance = LinkedList(input_) with pytest.raises(IndexError): linked_list_instance.pop()
def test_insert_two(): l_list = LinkedList() l_list.insert("David") l_list.insert("Thomas") assert l_list.head.get_data() == "Thomas" head_next = l_list.head.get_next() assert head_next.get_data() == "David"
def test_iterator(self): lst = LinkedList() lst.push(10) lst.push(20) iterator = iter(lst) self.assertEqual(next(iterator), 10) self.assertEqual(next(iterator), 20)
def test_insert_two(): l_list = LinkedList() l_list.insert("Shreyas") l_list.insert("Gune") assert l_list.head.get_data() == "Gune" head_next = l_list.head.get_next() assert head_next.get_data() == "Shreyas"
def test_finding_elements_on_empty_list() -> None: linked_list = LinkedList() linked_list.find(target_key="id", target_value="an_irrelevant_value") assert linked_list.head is None assert linked_list.tail is None
class Stack(object): def __init__(self, root=None): self.linked_list = LinkedList() if root is not None: self.push(root) def push(self, item): self.linked_list.insert_front(item) def pop(self): self.linked_list.delete_node(self.linked_list.head) def top(self): return self.linked_list.head.data def is_empty(self): if self.linked_list.head is None: return True return False def size(self): return self.linked_list.size()
def test_reversal_two(): """Test no errors arise when reversing a list of 2 items.""" from linked_list import LinkedList new_list = LinkedList([5, 20]) assert new_list.display() == '(20, 5)' new_list.reverse() assert new_list.display() == '(5, 20)'
def insert(self, data): LinkedList.insert(self, data) # This updates head, no previous needed on it if not self.tail: # There's nothing in the list! self.tail = self.head # This is the only thing, no previous or next else: # There was other stuff in the list, the old head (head.next) needs a previous self.head.next.previous = self.head self.head.previous = None # Need to define this attribute, since LinkedList.insert only makes a regular Node
def test_remove_last(self): l = LinkedList() l.add_first(1) l.add_first(2) self.assertEquals(1, l.remove_last()) self.assertEquals(1, len(l)) self.assertEquals('[2]', str(l))
def test_size(): joe = Node("Joe") bob = Node("Bob") new = LinkedList() new.insert(bob) new.insert(joe) assert new.size() == 2
def test_add_second_node(): joe = Node("Joe") bob = Node("Bob") new = LinkedList() new.insert(bob) new.insert(joe) assert new.first._next.val == "Bob"
def test_search_success(): joe = Node("Joe") bob = Node("Bob") new = LinkedList() new.insert(bob) new.insert(joe) assert new.search("Bob") == bob
def test_search_fail(): joe = Node("Joe") bob = Node("Bob") new = LinkedList() new.insert(bob) new.insert(joe) assert new.search("Fred") is None
class AssociativeArray: def __init__(self): self.items = LinkedList() def __unicode__(self): s = '' for key, value in self.items: s += repr(key) + ': ' + repr(value) + ', ' return '{' + s + '}' __repr__ = __unicode__ def put(self, key, value): for i, kv in enumerate(self.items): if kv[0] == key: l1 = self.items.take(i) l2 = self.items.drop(i + 1) self.items = l1.concat(l2) break self.items = self.items.append((key, value)) def get(self, key): for k, v in self.items: if k == key: return v
def get_representative_trajectory_average_inputs(trajectory_line_segments, min_lines, min_prev_dist): cur_active = [False] * len(trajectory_line_segments) active_list = LinkedList() insert_list = [] delete_list = [] out = [] line_segment_endpoints = get_sorted_line_seg_endpoints(trajectory_line_segments) i = 0 while i < len(line_segment_endpoints): insert_list[:] = [] delete_list[:] = [] prev_pos = line_segment_endpoints[i].horizontal_position while i < len(line_segment_endpoints) and numbers_within(line_segment_endpoints[i].horizontal_position, \ prev_pos, DECIMAL_MAX_DIFF_FOR_EQUALITY): if not cur_active[line_segment_endpoints[i].line_segment_id]: insert_list.append(line_segment_endpoints[i]) cur_active[line_segment_endpoints[i].line_segment_id] = True elif cur_active[line_segment_endpoints[i].line_segment_id]: delete_list.append(line_segment_endpoints[i]) cur_active[line_segment_endpoints[i].line_segment_id] = False i += 1 for line_seg_endpoint in insert_list: active_list.add_last_node(line_seg_endpoint.list_node) possibly_append_to_active_list(active_list, out, prev_pos, min_prev_dist, min_lines) for line_seg in delete_list: active_list.remove_node(line_seg.list_node) return out
def test_insert(): """Test insert method.""" from linked_list import LinkedList new_list = LinkedList() test_size = new_list.size() new_list.insert("test") assert test_size < new_list.size()
def test_search(): """Test search method.""" from linked_list import LinkedList new_list = LinkedList() new_list.insert([1, 2, 3, 4]) query = new_list.search(3) assert query.get_data() == 3
def compress_file(file_to_be_segmented, segment_length, output_location=None): """ A method to compress a file by segmenting the text then allocating an integer value to represent that segmented string then optimize the compression by creating a list of positions of each segment at a given time """ #Edge Case: we can't do anything if the segment_length doesn't make sense greater_than_zero_or_raise(segment_length) position_list = LinkedList() #doubly linkedlist of nodes that correspond to a segment for easy reordering segment = '' #to represent a section of text initial_legend = OrderedDict() #to store segment as a key with (corresponding LLNode reference, compression value) as value output_list = [] #the compressed text as a list of positions of compressed values from position_list compression_value = 0 #an integer to represent a segment counting from 0 up by when it was added current_letter_index = 1 #an interger to remember where in the text the current letter is for seeking back with open(file_to_be_segmented) as text: current_letter = text.read(1) while current_letter: segment += current_letter next_letter = text.read(1) text.seek(current_letter_index) current_letter_index += 1 #check if the segment is ready to be added if segment_ready_to_be_added(segment, segment_length, current_letter, next_letter): #if segment in dictionary: create an LLNode and add last position to output_list if segment in initial_legend: output_list.append(initial_legend[segment][0].position) position_list.move_to_head(initial_legend[segment][0]) segment = "" #if segment not in dictionary: find it in head and add position to output_list else: new_node = LLNode() position_list.add_to_head(new_node) output_list.append(compression_value) initial_legend[segment] = (new_node, compression_value) compression_value += 1 segment = "" current_letter = text.read(1) (output_list_as_string, output_legend) = format_printouts(output_list, initial_legend) if not output_location: print output_list_as_string print output_legend else: output_file = open(output_location, 'w+b') output_file.write(output_list_as_string + '\n') #print string object of output_list with spaces seperating numbers output_file.write(output_legend) #print string of dictionary values in order output_file.close()
def test_exists_method(self): linked_list = LinkedList() find_me = {'foo4': 'bar', 'bar': 123} self.assertFalse(linked_list.exists(find_me)) linked_list.insert(find_me) self.assertTrue(linked_list.exists(find_me))
def linked_list(): """Test fixture for linked list tests.""" from linked_list import LinkedList ll = LinkedList() ll.insert('a') ll.insert('b') ll.insert('c') return ll
def test_search_LinkedList(): from linked_list import Node test_list = LinkedList() test_list2 = LinkedList([1, 2, 3]) test_node = Node(3) assert test_list2.search(3).val == test_node.val assert test_list.search(50) is None assert test_list2.search(50) is None
def test_insert(): """Test insert works.""" from linked_list import LinkedList my_list = LinkedList() my_list.insert('a') my_list.insert('b') my_list.insert('c') assert my_list.head.val == 'c'
def test_retrieve_method(self): linked_list = LinkedList() find_me = {'foo4': 'bar', 'bar': 123} self.assertFalse(linked_list.retrieve(find_me)) linked_list.insert(find_me) self.assertEqual(find_me, linked_list.retrieve(find_me))
def test_delete_with_3_items(self): ll = LinkedList(['A', 'B', 'C']) assert ll.head.data == 'A' # First item assert ll.tail.data == 'C' # Last item ll.delete('A') assert ll.head.data == 'B' # New head assert ll.tail.data == 'C' # Unchanged ll.delete('C') assert ll.head.data == 'B' # Unchanged assert ll.tail.data == 'B' # New tail ll.delete('B') assert ll.head is None # No head assert ll.tail is None # No tail # Delete should raise error if item was already deleted with self.assertRaises(ValueError): ll.delete('A') # Item no longer in list with self.assertRaises(ValueError): ll.delete('B') # Item no longer in list with self.assertRaises(ValueError): ll.delete('C') # Item no longer in list
def test_count(self): self.assertEqual(LinkedList([1, 2, 3]).count(), 3)
from linked_list import LinkedList # Return Kth to Last: Implement an algorithm to find the kth to last element of a singly linked list. linked_list = LinkedList() linked_list.add(90) linked_list.add(2) linked_list.add(31) linked_list.add(7) linked_list.add(8) linked_list.add(9) linked_list.add(55) linked_list.add(12) linked_list.add(4) def kthToTheLast(k): head = linked_list.head tail = linked_list.head count = 1 while head != None and count < k: count += 1 head = head.next if (head == None): return None print("head: " + str(head.data)) print("tail: " + str(tail.data))
class LinkedListTests(unittest.TestCase): def setUp(self): self.linked_list = LinkedList() def tearDown(self): self.linked_list = None # test creation of empty linked list def test_create_linked_list(self): self.assertTrue(self.linked_list.is_empty()) # test appending different key value pairs to linked list def test_append_to_linked_list(self): self.linked_list.append("test", "testing") self.assertEqual("testing", self.linked_list.get("test")) self.assertTrue(self.linked_list.is_included("test")) self.assertFalse(self.linked_list.is_included("another test")) self.linked_list.append("another test", "testing!") self.assertEqual("testing!", self.linked_list.get("another test")) self.assertTrue(self.linked_list.is_included("another test")) # test that linked list is empty after appending and then # removing a node def test_remove_from_linked_list(self): node = self.linked_list.append("test", "testing") self.linked_list.remove("test") self.assertTrue(self.linked_list.is_empty()) # test that changing the associated value of a node with # a given key works def test_update_value_in_linked_list(self): self.linked_list.append("test", "testing") self.linked_list.update("test", "testing123") self.assertEqual("testing123", self.linked_list.get("test")) # test that returning all key value pairs in linked list works as expected def test_get_all_items_in_linked_list(self): self.linked_list.append("test", "testing") self.linked_list.append("testing!", "testing123!") self.assertEqual([('test', 'testing'), ('testing!', 'testing123!')], self.linked_list.items()) self.assertEqual(['test', 'testing!'], self.linked_list.keys()) self.assertEqual(['testing', 'testing123!'], self.linked_list.values())
def test_delete_with_item_not_in_list(self): ll = LinkedList(['A', 'B', 'C']) # Delete should raise error if item not found with self.assertRaises(ValueError): ll.delete('X') # Item not found in list
def setUp(self): self.list = LinkedList()
def test_remove_dups(self): ll_with_dups = LinkedList() ll_with_dups.append(2) ll_with_dups.append(3) ll_with_dups.append(2) ll_with_dups.append(5) ll_with_dups.append(6) ll_with_dups.append(1) ll_with_dups.append(2) ll_with_dups.append(2) self.assertEqual(ll_with_dups.length(), 8) self.assertEqual(ll_with_dups.to_s(), '2 3 2 5 6 1 2 2') ll_with_dups.remove_dups() self.assertEqual(ll_with_dups.length(), 5) self.assertEqual(ll_with_dups.to_s(), '2 3 5 6 1')
def setUp(self): self.ll = LinkedList(1) self.ll.append(2) self.ll.append(3) self.ll.append(4) self.gold = ['1','2','4']
def __init__(self, size): self.array_size = size #self.array = [None for i in range(size)] #self.array = [None] * size #self.array = [LinkedList() for i in range(size)] self.array = [LinkedList()] * size
def delete_mid(l_list): if isinstance(l_list, LinkedList): fast_ptr = l_list.head slow_ptr = l_list.head while fast_ptr is not None: try: fast_ptr = fast_ptr.next fast_ptr = fast_ptr.next except AttributeError: break slow_ptr = slow_ptr.next print(slow_ptr.data) else: raise Exception("param not of type 'LinkedList'") if __name__ == '__main__': ll = LinkedList() ll.push(1) ll.push(2) ll.push(3) ll.push(4) ll.push(5) ll.push(6) ll.push(7) print(ll) delete_mid(ll) print(ll)
temp = head prev = None while (temp and temp.next): if head == temp: head = temp.next swap_in_pairs(node1=temp, node2=temp.next, prev=prev) prev = temp temp = temp.next return head def swap_in_pairs(node1, node2, prev): temp = node2.next node2.next = node1 node1.next = temp if prev: prev.next = node2 if __name__ == '__main__': linked_list = LinkedList() llist = [1, 2, 3, 4, 5, 6, 7, 8, 9] linked_list.create_linked_list(input_list=llist) print("Linked list before") linked_list.print_list() current_head = linked_list.head new_head = reverse_in_pairs(head=current_head) new_list = LinkedList(head=new_head) print("Linked list after") new_list.print_list()
def __init__(self, capacity): self.capacity = capacity self.data = [LinkedList()] * capacity self.load = 0
def test_add_list(self): my_list = LinkedList() new_list = my_list + LinkedList([1]) self.assertEqual(new_list, LinkedList([1])) self.assertEqual(my_list, LinkedList()) my_list = LinkedList([1, 2]) new_list = my_list + LinkedList([3, 4]) self.assertEqual(new_list, LinkedList([1, 2, 3, 4])) self.assertEqual(my_list, LinkedList([1, 2])) my_list = LinkedList([1, 2]) new_list = my_list + LinkedList() self.assertEqual(new_list, LinkedList([1, 2])) self.assertEqual(my_list, LinkedList([1, 2])) my_list = LinkedList() new_list = my_list + LinkedList() self.assertEqual(new_list, LinkedList()) self.assertEqual(new_list.count(), 0) self.assertEqual(my_list, LinkedList()) self.assertEqual(my_list.count(), 0)
def test_unshift_pop(self): lst = LinkedList() lst.unshift(10) lst.unshift(20) self.assertEqual(lst.pop(), 10) self.assertEqual(lst.pop(), 20)
while current != None: current = current.next length += 1 current = linked_list.head while length > k: current = current.next length -= 1 return current.data """Optimized Solution""" def kth_o(linked_list, k): first = linked_list.head second = linked_list.head while first != None and k > 0: first = first.next k -= 1 while first is not None: first = first.next second = second.next return second.data if __name__ == '__main__': ll = LinkedList(['a', 'b', 'c', 'd', 'e', 'f']) print(kth(ll, 1)) print(kth_o(ll, 1))
def __init__(self, init_size=8): """Initialize this hash table with the given initial size.""" # Create a new list (used as fixed-size array) of empty linked lists self.buckets = [LinkedList() for _ in range(init_size)]
def test_pop_empty(): """Ensure that the pop method raises an error on an empty list.""" from linked_list import LinkedList test_linked_list = LinkedList() with pytest.raises(IndexError): test_linked_list.pop()
def test_delete_with_5_items(self): ll = LinkedList(['A', 'B', 'C', 'D', 'E']) assert ll.head.data == 'A' # First item assert ll.tail.data == 'E' # Last item ll.delete('A') assert ll.head.data == 'B' # New head assert ll.tail.data == 'E' # Unchanged ll.delete('E') assert ll.head.data == 'B' # Unchanged assert ll.tail.data == 'D' # New tail ll.delete('C') assert ll.head.data == 'B' # Unchanged assert ll.tail.data == 'D' # Unchanged ll.delete('D') assert ll.head.data == 'B' # Unchanged assert ll.tail.data == 'B' # New tail ll.delete('B') assert ll.head is None # No head assert ll.tail is None # No tail
class TestLinkedList(unittest.TestCase): def setUp(self): self.list = LinkedList() def tearDown(self): self.list = None def test_append(self): self.list.append("Mr. Green") self.assertTrue(self.list.head.data == "Mr. Green") self.assertTrue(self.list.head.next_node is None) def test_append_two(self): self.list.append("Mr. Green") self.list.append("Miss Scarlet") self.assertTrue(self.list.head.data == "Miss Scarlet") new_head = self.list.head.next_node self.assertTrue(new_head.data == "Mr. Green") def test_next_node(self): self.list.append("Prof. Plum") self.list.append("Mrs. Peacock") self.list.append("Mr. Boddy") self.assertTrue(self.list.head.data == "Mr. Boddy") new_head = self.list.head.next_node self.assertTrue(new_head.data == "Mrs. Peacock") last = new_head.next_node self.assertTrue(last.data == "Prof. Plum") def test_len(self): self.list.append("Prof. Plum") self.list.append("Mrs. Peacock") self.list.append("Mr. Boddy") length = self.list.__len__() self.assertTrue(length == 3) def test_len_zero(self): length = self.list.__len__() self.assertTrue(length == 0) def test_len_one(self): self.list.append("Prof. Plum") length = self.list.__len__() self.assertTrue(length == 1) def test_succeed_getitem(self): self.list.append("Prof. Plum") self.list.append("Mrs. Peacock") self.list.append("Mr. Boddy") result = self.list.__getitem__(0) self.assertTrue(result == "Mr. Boddy") result = self.list.__getitem__(1) self.assertTrue(result == "Mrs. Peacock") result = self.list.__getitem__(2) self.assertTrue(result == "Prof. Plum") def test_fail_getitem(self): self.list.append("Prof. Plum") self.list.append("Mrs. Peacock") with self.assertRaises(IndexError): self.list.__getitem__(2) #@unittest.skip('Extra Challenge: pop method.') def test_pop(self): self.list.append("Prof. Plum") self.list.append("Mrs. Peacock") self.list.append("Mr. Boddy") old_head = self.list.pop() self.assertTrue(old_head.data == "Mr. Boddy") new_head = self.list.head self.assertTrue(new_head.data == "Mrs. Peacock") new_length = len(self.list) self.assertTrue(new_length == 2) #@unittest.skip('Extra Challenge: pop method.') def test_pop_empty_list(self): with self.assertRaises(IndexError): self.list.pop() #@unittest.skip('Extra Challenge: __delitem__ method.') def test_delete(self): self.list.append("Prof. Plum") self.list.append("Mrs. Peacock") self.list.append("Mr. Boddy") # Delete the list head self.list.__delitem__(0) self.assertTrue(self.list.head.data == "Mrs. Peacock") # Delete the list tail self.list.__delitem__(1) self.assertTrue(self.list.head.next_node is None) new_length = len(self.list) self.assertTrue(new_length == 1) #@unittest.skip('Extra Challenge: __delitem__ method.') def test_delete_value_not_in_list(self): self.list.append("Prof. Plum") self.list.append("Mrs. Peacock") self.list.append("Mr. Boddy") with self.assertRaises(IndexError): self.list.__delitem__(3) #@unittest.skip('Extra Challenge: __delitem__ method.') def test_delete_empty_list(self): with self.assertRaises(IndexError): self.list.__delitem__(1) #@unittest.skip('Extra Challenge: __delitem__ method.') def test_delete_next_reassignment(self): self.list.append("Prof. Plum") self.list.append("Mrs. White") self.list.append("Mrs. Peacock") self.list.append("Mr. Boddy") self.list.__delitem__(1) self.list.__delitem__(1) self.assertTrue(self.list.head.next_node.data == "Prof. Plum")
def test_search_found(): """Test that push value to list then search for it.""" from linked_list import LinkedList test_linked_list = LinkedList() test_linked_list.push(20) assert test_linked_list.search(20)
def list_fixture(): from linked_list import LinkedList l = LinkedList() return l
def __init__(self, size): self.array_size = size self.array = [LinkedList() for i in range(size)]
node = lst.root while node: if node.data < x: data = node.data lst.delete(node.data) lst.add(data) node = node.next #test n = lst.root line = "" while n: line += str(n.data) + "," n = n.next print(line) if __name__ == "__main__": l = LinkedList(1) l.add(4) l.add(2) l.add(7) l.add(5) partition_list(l, 4) #shold return #4,2,1,5,7
def __init__(self): self.storage = LinkedList()
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Mon Jan 28 12:54:49 2019 @author: pabloruizruiz """ from linked_list import LinkedList def delete_middle_node(node): message = "Node to delete can't be head or tail nodes from the list" assert node.next is not None, message node.data = node.next.data node.next = node.next.next ll = LinkedList() ll.add_multiple([7, 4, 3]) middle_node = ll.add(5) ll.add_multiple([7, 4, 3]) print(ll) delete_middle_node(middle_node) print(ll)
def test_push_pop(self): lst = LinkedList() lst.push(10) lst.push(20) self.assertEqual(lst.pop(), 20) self.assertEqual(lst.pop(), 10)
def test_add_equals_list(self): my_list = LinkedList() my_list += LinkedList([1, 2]) self.assertEqual(my_list, LinkedList([1, 2])) my_list = LinkedList([1, 2]) my_list += LinkedList([3, 4]) self.assertEqual(my_list, LinkedList([1, 2, 3, 4])) my_list = LinkedList([1, 2]) my_list += LinkedList() self.assertEqual(my_list, LinkedList([1, 2])) my_list = LinkedList() my_list += LinkedList() self.assertEqual(my_list.count(), 0) self.assertEqual(my_list, LinkedList())
def test_all(self): lst = LinkedList() lst.push(10) lst.push(20) self.assertEqual(lst.pop(), 20) lst.push(30) self.assertEqual(lst.shift(), 10) lst.unshift(40) lst.push(50) self.assertEqual(lst.shift(), 40) self.assertEqual(lst.pop(), 50) self.assertEqual(lst.shift(), 30)
def test_init(self): ll = LinkedList() # Initializer should add instance properties assert ll.head is None # First node assert ll.tail is None # Last node
def test_find(self): ll = LinkedList(['A', 'B', 'C']) assert ll.find(lambda item: item == 'B') == 'B' # Match equality assert ll.find(lambda item: item < 'B') == 'A' # Match less than assert ll.find(lambda item: item > 'B') == 'C' # Match greater than assert ll.find(lambda item: item == 'X') is None # No matching item