def test_insert_invalid_ref(self): ll = sllist([1, 2, 3, 4]) self.assertRaises(TypeError, ll.insertafter, 10, 1) self.assertRaises(TypeError, ll.insertafter, 10, 'abc') self.assertRaises(TypeError, ll.insertafter, 10, []) self.assertRaises(ValueError, ll.insertafter, 10, sllistnode()) self.assertRaises(TypeError, ll.insertbefore, 10, 1) self.assertRaises(TypeError, ll.insertbefore, 10, 'abc') self.assertRaises(TypeError, ll.insertbefore, 10, []) self.assertRaises(ValueError, ll.insertbefore, 10, sllistnode())
def test_insert_node_with_invalid_ref(self): ll = sllist([1, 2, 3, 4]) self.assertRaises(TypeError, ll.insertnodeafter, sllistnode(10), 1) self.assertRaises(TypeError, ll.insertnodeafter, sllistnode(10), 'abc') self.assertRaises(TypeError, ll.insertnodeafter, sllistnode(10), []) self.assertRaises( ValueError, ll.insertnodeafter, sllistnode(10), sllistnode()) self.assertRaises(TypeError, ll.insertnodebefore, sllistnode(10), 1) self.assertRaises(TypeError, ll.insertnodebefore, sllistnode(10), 'abc') self.assertRaises(TypeError, ll.insertnodebefore, sllistnode(10), []) self.assertRaises( ValueError, ll.insertnodebefore, sllistnode(10), sllistnode())
def test_remove_from_n_elem(self): ll = sllist() nn = sllistnode() ll.append(nn) to_del = ll.nodeat(0) ll.remove(to_del) self.assertEqual(None, None)
def test_insertnodeafter_with_invalid_type_of_inserted_node(self): ll = dllist([0]) self.assertRaises(TypeError, ll.insertnodeafter, None, ll.first) self.assertRaises(TypeError, ll.insertnodeafter, 'non-node argument', ll.first) self.assertRaises(TypeError, ll.insertnodeafter, sllistnode(1234), ll.first)
def distribute(Arr, d, sll): reminder = [0] * (len(Arr)) for i in range(0, len(Arr)): # to get digits in the position we want we use r = (Arr[i] / 10**d) % 10 reminder[i] = r # print reminder # now distribute these values in single linked list for n in range(9, -1, -1): for m in range(len(Arr) - 1, -1, -1): if sll.size == 0 and reminder[m] == n: sll.append(Arr[m]) Arr.pop(m) reminder.pop(m) elif sll.size > 0 and reminder[m] == n: new_node = sllistnode(Arr[m]) sll.appendleft(new_node) Arr.pop(m) reminder.pop(m) # print sll m -= 1 return sll
def test_node_readonly_attributes(self): if sys.hexversion >= 0x03000000: expected_error = AttributeError else: expected_error = TypeError ll = sllistnode() self.assertRaises(expected_error, setattr, ll, 'next', None)
def test_insertnodeafter_with_invalid_type_of_ref_node(self): ll = dllist([0]) self.assertRaises(TypeError, ll.insertnodeafter, dllistnode(1234), None) self.assertRaises(TypeError, ll.insertnodeafter, dllistnode(1234), 'not a dllist node') self.assertRaises(TypeError, ll.insertnodeafter, dllistnode(1234), sllistnode(1234))
def test_cyclic_list_destruction_does_not_release_extra_None_refs(self): original_ref_count = sys.getrefcount(None) for _ in range(original_ref_count * 10): ll = sllist() ll.append(sllistnode(ll)) del ll self.assertGreater(sys.getrefcount(None), 0)
def test_insert_node_before_first(self): ll = sllist(py23_xrange(4)) ref = sllist([10, 0, 1, 2, 3]) next = ll.nodeat(0) arg_node = sllistnode(10) new_node = ll.insertnodebefore(arg_node, ll.nodeat(0)) self.assertEqual(new_node, arg_node) self.assertEqual(new_node.value, 10) self.assertEqual(new_node.next, next) self.assertEqual(new_node, ll.first) self.assertEqual(ll, ref)
def test_appendleft(self): ll = sllist(py23_xrange(4)) ref = sllist([10, 0, 1, 2, 3]) next = ll.nodeat(0) arg_node = sllistnode(10) new_node = ll.appendleft(arg_node) self.assertNotEqual(new_node, arg_node) self.assertEqual(new_node.value, 10) self.assertEqual(new_node.next, next) self.assertEqual(ll.first, new_node) self.assertEqual(ll, ref)
def test_insert_value_after(self): ll = sllist(py23_xrange(4)) ref = sllist([0, 1, 2, 10, 3]) prev = ll.nodeat(2) next = ll.nodeat(3) arg_node = sllistnode(10) new_node = ll.insertafter(arg_node, ll.nodeat(2)) self.assertNotEqual(new_node, arg_node) self.assertEqual(new_node.value, 10) self.assertEqual(new_node.next, next) self.assertEqual(prev.next, new_node) self.assertEqual(ll, ref)
def test_appendright(self): ll = sllist(py23_xrange(4)) ref = sllist([0, 1, 2, 3, 10]) prev = ll.nodeat(-1) arg_node = sllistnode(10) new_node = ll.appendright(arg_node) self.assertNotEqual(new_node, arg_node) self.assertEqual(new_node.value, 10) self.assertEqual(new_node.next, None) self.assertEqual(prev.next, new_node) self.assertEqual(ll.last, new_node) self.assertEqual(ll, ref)
def test_insert_node_before_another(self): ll = sllist(py23_xrange(4)) ref = sllist([0, 1, 10, 2, 3]) prev = ll.nodeat(1) next = ll.nodeat(2) arg_node = sllistnode(10) new_node = ll.insertnodebefore(arg_node, ll.nodeat(2)) self.assertEqual(new_node, arg_node) self.assertEqual(new_node.value, 10) self.assertEqual(new_node.next, next) self.assertEqual(prev.next, new_node) self.assertEqual(ll, ref)
def test_insert_node_after_last(self): ll = sllist(py23_xrange(4)) ref = sllist([0, 1, 2, 3, 10]) prev = ll.nodeat(3) arg_node = sllistnode(10) new_node = ll.insertnodeafter(arg_node, ll.nodeat(-1)) self.assertEqual(new_node, arg_node) self.assertEqual(new_node.value, 10) self.assertEqual(new_node.next, None) self.assertEqual(prev.next, new_node) self.assertEqual(new_node, ll.last) self.assertEqual(ll, ref)
def addTwoNumbers(l1, l2): dummy = sllist() carry = 0 n1 = l1.first n2 = l2.first sum = dummy.first while n1 or n2 or carry: if n1: carry += n1.value n1 = n1.next if n2: carry += n2.value n2 = n2.next sum = dummy.append(sllistnode(carry % 10)) carry //= 10 sum = sum.next return dummy
def test_appendnode(self): ll = sllist([1, 2, 3, 4]) node = sllistnode(5) ll.appendnode(node) self.assertEqual([1, 2, 3, 4, 5], list(ll)) self.assertIs(node, ll.last)
def test_insert_node_before_refcount_update(self): ll = sllist([1234]) node = ll.insertnodebefore(sllistnode(5678), ll.nodeat(0)) self.assertGreaterEqual(sys.getrefcount(node), 3)
def test_appendnode_refcount_update(self): ll = sllist() node = ll.appendnode(sllistnode(1234)) self.assertGreaterEqual(sys.getrefcount(node), 3)
def test_repr_recursive_list(self): ll = sllist() ll.append(sllistnode(ll)) self.assertEqual(repr(ll), 'sllist([sllist(<...>)])')
def test_remove_from_empty_list(self): ll = sllist() self.assertRaises(ValueError, ll.remove, sllistnode())
def make_recursive_node_list(self): ll = sllist() node = sllistnode() node.value = node ll.append(node) return ll
def test_insert_node_after_first(self): ll = sllist([1, 3, '123']) arg_node = sllistnode(100) new_node = ll.insertnodeafter(arg_node, ll.first) self.assertEqual([1, 100, 3, '123'], list(ll)) self.assertEqual(new_node, arg_node);
def test_remove_invalid_node(self): ll = sllist([1, 2, 3, 4]) self.assertRaises(ValueError, ll.remove, sllistnode()) self.assertEqual(len(ll), 4)
def test_insert_node_before_first(self): ll = sllist([1, 3, '123']) arg_node = sllistnode(100) new_node = ll.insertnodebefore(arg_node, ll.first) self.assertEqual([100, 1, 3, '123'], list(ll)) self.assertEqual(new_node, arg_node);