예제 #1
0
 def test_ex2(self):
     self.assertEqual(
         ex2.k_last_element(linked_list.from_list([1, 2, 3, 4, 5]), 1), 5
     )
     self.assertEqual(
         ex2.k_last_element(linked_list.from_list([1, 2, 1, 4, 5]), 3), 1
     )
예제 #2
0
 def test_ex3(self):
     expected = [1, 2, 3, 5]
     L = linked_list.from_list([1, 2, 3, 4, 5])
     ex3.delete_value(L, 4)
     self.assertEqual(linked_list.to_list(L), expected)
     expected = [1, 2, 3, 4, 5]
     L = linked_list.from_list([1, 2, 3, 4, 5])
     ex3.delete_value(L, 6)
     self.assertEqual(linked_list.to_list(L), expected)
예제 #3
0
 def test_ex1(self):
     expected = [1, 2, 3, 4, 5]
     result = linked_list.to_list(
         ex1.remove_dups(linked_list.from_list([1, 2, 3, 4, 5]))
     )
     self.assertEqual(result, expected)
     expected = [1, 2, 4, 5]
     result = ex1.linked_list.to_list(
         ex1.remove_dups(linked_list.from_list([1, 2, 1, 4, 5]))
     )
     self.assertEqual(result, expected)
예제 #4
0
def test_reverse_works():
    for _ in xrange(100):
        lst = [ri(1, 20) for _2 in xrange(20)]
        head = ll.from_list(lst)
        rhead = ll.reverse(head)
        rlst = ll.to_list(rhead)
        assert rlst == lst[::-1]
예제 #5
0
def test_doubly_from_list():
    lst = [1, 2, 3]
    head = ll.from_list(lst, True)
    assert type(head) == ll.DLL
    assert head.data == 1 and head.prev is None
    assert head.nxt.data == 2 and head.nxt.prev == head
    assert head.nxt.nxt.data == 3 and head.nxt.nxt.prev == head.nxt
    assert head.nxt.nxt.nxt is None
예제 #6
0
def test_from_list():
    lst = [1, 2, 3]
    head = ll.from_list(lst)
    assert type(head) == ll.LL
    assert head.data == 1
    assert head.nxt.data == 2
    assert head.nxt.nxt.data == 3
    assert head.nxt.nxt.nxt is None
예제 #7
0
def test_len_works():
    for _ in xrange(10):
        length = ri(1, 100)
        curr = head = ll.from_list(range(length), True)
        steps = ri(0, length - 1)
        while steps > 0:
            curr, steps = curr.nxt, steps - 1
        assert len(curr) == length
예제 #8
0
def test_backward_iteration_works():
    lst = range(3)
    head = ll.from_list(lst, True)
    last = head.nxt.nxt
    for i, el in enumerate(ll.iter_list(last, True)):
        assert el.data == lst[2 - i]
예제 #9
0
def test_iteration_works():
    lst = range(3)
    head = ll.from_list(lst, True)
    for i, el in enumerate(ll.iter_list(head)):
        assert el.data == lst[i]
예제 #10
0
 def test_ex8(self):
     L = linked_list.from_list([1, 2, 3, 4])
     L.next.next.next.next = L.next
     self.assertTrue(ex8.find_loop(L) is L.next)
     self.assertIsNone(ex8.find_loop(linked_list.from_list([1, 2, 3])))
예제 #11
0
 def test_ex7(self):
     l1 = linked_list.from_list([1, 2, 3, 4, 5])
     l2 = linked_list.from_list([1, 2, 3, 4, 5])
     l3 = l1.next.next
     self.assertIsNone(ex7.intersection_node(l1, l2))
     self.assertEqual(ex7.intersection_node(l1, l3), l3)
예제 #12
0
 def test_ex6(self):
     self.assertTrue(ex6.is_palindrome(linked_list.from_list([7, 1, 5, 1, 7])))
     self.assertFalse(ex6.is_palindrome(linked_list.from_list([7, 1, 5, 1, 8])))
예제 #13
0
 def test_ex5(self):
     x1 = linked_list.from_list([7, 1, 6])
     x2 = linked_list.from_list([5, 9, 2])
     expected = linked_list.from_list([2, 1, 9])
     self.assertEqual(ex5.sum_lists(x1, x2), expected)
예제 #14
0
    first_half = Stack()
    slow_runner = head
    fast_runner = head
    while fast_runner:
        fast_runner = fast_runner.next
        if fast_runner:
            fast_runner = fast_runner.next
            first_half.push(slow_runner.value)
        slow_runner = slow_runner.next

    while slow_runner:
        if slow_runner.value != first_half.pop():
            return False
        slow_runner = slow_runner.next
    return True

print(is_palindrome2(linked_list.from_list([7, 1, 5, 1, 7])))
print(is_palindrome2(linked_list.from_list([7, 1, 5, 1, 8])))

def _reverse_list(L):
    r = None
    while L is not None:
        r = linked_list.Node(L.value, r)
        L = L.next
    return r


def is_palindrome(L):
    return _reverse_list(L) == L

예제 #15
0
import linked_list

def partition(head, x):
    first = head.value
    second = head.next.value
    if first > second:
        first, second = second, first
    high = linked_list.Node(second, None)
    low = linked_list.Node(first, high)
    head = head.next.next
    while head:
        if head.value >= x:
            high.next = linked_list.Node(head.value, None)
            high = high.next
        else:
            low = linked_list.Node(head.value, low)
        head = head.next
    return low

L = linked_list.from_list([1, 5, 10, 3, 4, 6])
l = partition(L, 5)
print(l)
예제 #16
0
def test_representation_works():
    head = ll.from_list(range(3), True)
    assert repr(head) == "0<->1<->2"
예제 #17
0
 def test_ex4(self):
     # expected_low = Counter([1, 3, 4])
     # expected_high = Counter([5, 6, 10])
     L = linked_list.from_list([1, 5, 10, 3, 4, 6])
     l = ex4.partition(L, 5)
     print(l)
예제 #18
0
def test_len_works():
    for _ in xrange(10):
        length = ri(1, 100)
        head = ll.from_list(range(length))
        assert len(head) == length