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()
