def test_is_empty(self): """Test is_empty method.""" ul = UnorderedList() self.assertTrue(ul.is_empty()) ul.head = Node(1) self.assertFalse(ul.is_empty())
smallest_so_far = cur prev_to_smallest_so_far = prev prev = cur cur = cur.next # if the smallest element is at the head of the linked list: if prev_to_smallest_so_far is None: ll.head = smallest_so_far.getNext() smallest_so_far = None else: prev_to_smallest_so_far.setNext(smallest_so_far.getNext()) #print("Previous {} Smallest {}".format(prev_to_smallest_so_far.data, smallest_so_far.data)) if __name__ == '__main__': lo = UnorderedList() lo.add(1) lo.add(3) lo.add(2) lo.add(15) lo.add(5) lo.add(10) lo.add(7) lo.add(8) lo.add(15) print("***********************") print(lo.lprint()) print(lo.toArray()) print("***********************") print("***********************") remove_minimum(lo)
current == ll.head while current: runner = current while runner.next: # if next is the same as current, then skip it if runner.next.value == current.value: runner.next = runner.next.next else: runner = runner.next current = current.next return ll if __name__ == '__main__': ll = UnorderedList() ll.add(1) ll.add(2) ll.add(2) ll.add(3) ll.add(3) ll.add(3) ll.add(4) ll.add(4) ll.add(4) ll.add(4) ll.printList() ll = removeDups(ll) print "after removeDups" ll.printList()
def test_initially_points_to_empty(self): """An immediately instantiated UL must point to None.""" ul = UnorderedList() self.assertIsNone(ul.head)
fast = ll.head has_loop = False while fast.next is not None and fast.next.next is not None: slow = slow.next fast = fast.next.next print("Fast: {} Slow: {}".format(fast.data, slow.data)) if slow.data == fast.data: has_loop = True break return has_loop if __name__ == '__main__': lo = UnorderedList() lo.add(1) lo.add(3) lo.add(2) lo.add(15) lo.add(5) lo.add(10) lo.add(7) lo.add(8) cur = lo.head center = None while cur.next is not None: if cur.data == 15: center = cur cur = cur.next
from linkedlist import Node from linkedlist import UnorderedList list1 = UnorderedList() list1.add(12) list1.add(40) list1.add(45) list1.append(67) print(list1.index(34)) list1.printList()
from linkedlist import UnorderedList mylist = UnorderedList() mylist.add(40) mylist.add(13) mylist.add(32) mylist.add(97) print(mylist.search(13))
if n2: result += n2.value n2 = n2.next singles = result % 10 ll.add(singles) carry = result // 10 if carry is not 0: ll.add(carry) return ll if __name__ == '__main__': ll1 = UnorderedList() ll2 = UnorderedList() ll1.add(7) ll1.add(1) ll1.add(6) ll1.printList() print "+" ll2.add(5) ll2.add(9) ll2.add(2) ll2.printList() ll = UnorderedList() ll = sumlist(ll1, ll2) print "="
def deleteMiddle(node): """ modified my linked list implementation to return the node, when adding to list set next, to next next """ node.value = node.next.value node.next = node.next.next if __name__ == '__main__': """ delete 100 from list """ ll = UnorderedList() ll.add(1) ll.add(2) ll.add(3) ll.add(4) ll.add(5) middle = ll.add(100) ll.add(6) ll.add(7) ll.add(8) ll.add(9) ll.add(0) ll.printList() print "deleteMiddle" deleteMiddle(middle)
from linkedlist import UnorderedList def kth_to_last(ll, k): current = ll.head for i in range(k): current = current.next return current.value if __name__ == '__main__': ll = UnorderedList() ll.add(1) ll.add(2) ll.add(3) ll.add(4) ll.add(5) ll.add(6) ll.add(7) ll.add(8) ll.add(9) ll.add(0) ll.printList() print "kth to last" print kth_to_last(ll, 3)
def sumList(l1, l2): """ Sum Lists: You have two numbers represented by a linked list, where each node contains a single digit. The digits are stored in reverse order, such that the 1st digit is at the head of the list. Write a function that adds the two numbers and returns the sum as a linked list. Example: Input: (7->1->6) + (5->9->2). That is 617 + 295 Ouptut: 2->1->9. That is 912 Follow up Suppose the digits are stored in a forward order. Repeat the above problem. Input: (6->1->7) + (2->9->5). That is 617 + 295 Output: 9->1->2. That is 912. """ #First Case: #Since the number is already in reversed order, we can #just add each values togeter like you would do when #manually adding two numbers. Like so, # 7->1->6 #+5->9->2 #We do the following: #1. Add 7+5, getting 12. it is above 9 so result is 12-10 =2, #with carry over of 1 #2. Add 1+9 +1 carry over from before, getting 11, again is #above 9 so 11-10 = 1, with carry over of 1 again #3. Add 6+2 +1 from carry over, getting 9 it is not above 9, so #no carry over in this case. dum = current = UnorderedList() remainder = 0 l1 = l1.head l2 = l2.head while l1 != None and l2 != None: temp = l1.data + l2.data + remainder if temp > 9: current.add(temp - 10) carryover = 1 else: current.add(temp) carryover = 0 l1 = l1.next l2 = l2.next while l1 != None: temp = l1.data + remainder if temp > 9: current.add(temp - 10) carryover = 1 else: current.add(temp) carryover = 0 l1 = l1.next while l2 != None: temp = l2.data + remainder if temp > 9: current.add(temp - 10) carryover = 1 else: current.add(temp) carryover = 0 l2 = l2.next if carryover != 0: current.add(1) return dum
class TestLinkedList(unittest.TestCase): def setUp(self): self.ll = UnorderedList() def test_empty(self): self.assertFalse(self.ll) self.assertEqual(0, len(self.ll)) def test_add_item(self): self.ll.add(1) self.assertEqual(1, self.ll.head.data) def test_items_in_reverse_order_added(self): self.add_many() self.assertEqual(3, self.ll.head.data) self.assertEqual(1, self.ll.tail.data) def test_append(self): self.add_many() self.ll.append(4) self.assertEqual(4, self.ll.tail.data) def test_append_when_empty(self): self.ll.append(7) self.assertEqual(7, self.ll.head.data) def test_find(self): self.add_many() self.assertTrue(self.ll.find(3)) self.assertFalse(self.ll.find(5)) def test_insert(self): self.add_many() self.ll.insert(4, 1) self.assertEqual(4, self.ll.head.next.data) def test_insert_out_of_bounds(self): self.add_many() self.ll.insert(4, 100) self.assertEqual(3, len(self.ll)) def add_many(self): self.ll.add(1) self.ll.add(2) self.ll.add(3)
def setUp(self): self.ll = UnorderedList()