def test_top(self): ll = LinkedList() self.assertEqual(None,ll.top()) ll.add_node(10) ll.add_node(8) ll.add_new_tail(5) self.assertEqual(8,ll.top())
def test_pop(self):
ll = LinkedList()
self.assertEqual(None,ll.pop())
self.assertEqual('',ll.show_elements())
ll.add_node(10)
ll.add_node(8)
ll.add_new_tail(5)
self.assertEqual(8,ll.pop())
self.assertEqual('10->5->',ll.show_elements())
def test_even_list(self):
"""
Тестовый случай со связным списком из чётного количества нодов.
"""
letters = LinkedList()
letters.add_node(Node('A'))
letters.add_node(Node('D'))
letters.add_node(Node('D'))
letters.add_node(Node('A'))
result = is_palindrome(letters)
self.assertEqual(result, True)
def test_no_palindrome_list(self):
"""
Тестовый случай со связным списоком, который не является палиндромом.
"""
letters = LinkedList()
letters.add_node(Node('A'))
letters.add_node(Node('D'))
letters.add_node(Node('D'))
letters.add_node(Node('D'))
result = is_palindrome(letters)
self.assertEqual(result, False)
def test_add_node(self):
ll = LinkedList()
self.assertEqual(True,ll.is_empty())
self.assertEqual('',ll.show_elements())
ll.add_node(10)
self.assertEqual(False,ll.is_empty())
self.assertEqual('10->',ll.show_elements())
ll.add_node(8)
ll.add_node(1)
self.assertEqual('1->8->10->',ll.show_elements())
def test_remove_repeated_wihtout_buffer(self): ll = LinkedList() ll.add_node(10) ll.add_node(8) ll.add_node(12) ll.add_node(3) ll.add_node(5) ll.add_node(7) self.assertEqual([3,12,8,10],ll.find_last_n(3)) self.assertEqual([7,5,3,12,8,10],ll.find_last_n(1)) self.assertEqual([10],ll.find_last_n(6))
def sum_linked_lists(left_list, right_list):
"""
Суммирует каждый из нодов двух связных списков, возвращая итоговый
связный список.
:param left_list: первый связный список.
:param right_list: второй связный список.
:return: связный список из просуммированных нодов в прямом порядке.
"""
result_list = LinkedList()
left_list_iter = iter(left_list)
right_list_iter = iter(right_list)
while True:
try:
left_node = next(left_list_iter)
right_node = next(right_list_iter)
except StopIteration:
break
else:
result_list.add_node(Node(left_node.data + right_node.data))
return result_list
def test_descending_numbers(self):
"""
Тестовый случай с числами, распределёнными по убыванию.
"""
numbers = LinkedList()
numbers.add_node(Node(8))
numbers.add_node(Node(7))
numbers.add_node(Node(6))
numbers.add_node(Node(5))
numbers.add_node(Node(4))
numbers.add_node(Node(3))
numbers.add_node(Node(2))
numbers.add_node(Node(1))
result_list = [item.data for item in distribute_nodes(numbers, 4)]
self.assertEqual(result_list, [3, 2, 1, 8, 7, 6, 5, 4])
def test_numbers(self):
"""
Тестовый случай со случайно распределёнными числами.
"""
numbers = LinkedList()
numbers.add_node(Node(21))
numbers.add_node(Node(12))
numbers.add_node(Node(55))
numbers.add_node(Node(33))
numbers.add_node(Node(52))
numbers.add_node(Node(51))
numbers.add_node(Node(31))
numbers.add_node(Node(44))
result_list = [item.data for item in distribute_nodes(numbers, 37)]
self.assertEqual(result_list, [21, 12, 33, 31, 55, 52, 51, 44])
def test_add_new_tail(self):
ll = LinkedList()
ll.add_node(10)
ll.add_node(8)
ll.add_new_tail(5)
self.assertEqual('8->10->5->',ll.show_elements())
ll.add_node(6)
self.assertEqual('6->8->10->5->',ll.show_elements())
def sum_reversed_linked_lists(left_list, right_list):
"""
Суммирует каждый из нодов двух связных в обратном порядке, возвращая
итоговый связный список.
:param left_list: первый связный список.
:param right_list: второй связный список.
:return: связный список из просуммированных нодов в обратном порядке.
"""
result_list = LinkedList()
nodes_list = []
left_list_iter = iter(left_list)
right_list_iter = iter(right_list)
while True:
try:
left_node = next(left_list_iter)
right_node = next(right_list_iter)
except StopIteration:
break
else:
nodes_list.append(Node(left_node.data + right_node.data))
for node in nodes_list[::-1]:
result_list.add_node(node)
return result_list
def test_linked_list(self):
"""
Тестовый случай со связным списком из букв.
"""
letters = LinkedList()
letters.add_node(Node('A'))
letters.add_node(Node('B'))
letters.add_node(Node('C'))
letters.add_node(Node('D'))
letters.add_node(Node('E'))
result = find_node(letters, 2).data
self.assertEqual(result, 'D')
def test_linked_list(self):
"""
Тестовый случай со связным списком из букв.
"""
letters = LinkedList()
letters.add_node(Node('A'))
letters.add_node(Node('B'))
letters.add_node(Node('C'))
letters.add_node(Node('D'))
letters.add_node(Node('E'))
result_list = [item.data for item in remove_central_node(letters)]
self.assertEqual(result_list, ['A', 'B', 'D', 'E'])
def test_linked_lists(self):
"""
Тестовый случай со стандартыми связными списками с нодами из чисел.
"""
linked_list_1 = LinkedList()
linked_list_1.add_node(Node(1))
linked_list_1.add_node(Node(2))
linked_list_1.add_node(Node(3))
linked_list_2 = LinkedList()
linked_list_2.add_node(Node(4))
linked_list_2.add_node(Node(5))
linked_list_2.add_node(Node(6))
result = [
node.data
for node in sum_reversed_linked_lists(linked_list_1, linked_list_2)
]
self.assertEqual(result, [9, 7, 5])
def test_standard_linked_list(self):
"""
Тестовый случай, где передан связный список без петель.
Функция должна вернуть None.
"""
numbers = LinkedList()
numbers.add_node(Node(1))
numbers.add_node(Node(2))
numbers.add_node(Node(3))
numbers.add_node(Node(4))
numbers.add_node(Node(5))
result = get_list_circle_root(numbers)
self.assertEqual(result, None)
def test_circled_linked_list(self):
"""
Тестовый случай, где передан связный список с петлёй на
ноде со значением 2.
"""
numbers = LinkedList()
numbers.add_node(Node(1))
numbers.add_node(Node(2))
numbers.add_node(Node(3))
numbers.add_node(Node(4))
numbers.add_node(Node(5))
numbers.peak().next_node = numbers.head_node.next_node
result = get_list_circle_root(numbers)
self.assertEqual(result.data, 2)
def test_remove_node(self):
ll = LinkedList()
ll.add_node(10)
ll.add_node(8)
ll.add_node(12)
ll.add_new_tail(5)
self.assertEqual('12->8->10->5->',ll.show_elements())
ll.remove_node(10)
self.assertEqual('12->8->5->',ll.show_elements())
ll.remove_node(12)
self.assertEqual('8->5->',ll.show_elements())
ll.remove_node(5)
self.assertEqual('8->',ll.show_elements())
def test_add_range10(self):
ll = LinkedList()
for i in range(9,0,-2) + range(0,10,2): ll.add_node(i)
assert_equals(range(10), [x for x in ll.walk()])
def test_float(self):
ll = LinkedList()
for i in [1, 1.0, 1.1, 0.9]: ll.add_node(i)
assert_equals([0.9, 1, 1.0, 1.1], [x for x in ll.walk()])
def test_add_one(self):
ll = LinkedList()
for i in [1]: ll.add_node(i)
assert_equals([1], [x for x in ll.walk()])
if not is_last_node_equal(list_1, list_2):
return None
current_node_longest = list_1.head if list_1.count > list_2.count else list_2.head
current_node_shortest = list_2.head if list_2.count < list_1.count else list_1.head
count_difference = abs(list_1.count - list_2.count)
for i in range(0, count_difference):
current_node_longest = current_node_longest.next
while current_node_longest != None and current_node_shortest != None:
if current_node_longest is current_node_shortest:
return current_node_longest
current_node_longest = current_node_longest.next
current_node_shortest = current_node_shortest.next
list_1 = LinkedList(1)
list_1.add(2)
list_1.add(5)
intersected_node = list_1.head
list_1.add(6)
list_1.add(7)
list_1.add(8)
list_2 = LinkedList(3)
list_2.add(4)
list_2.add_node(intersected_node)
print(get_intersected_node(list_1, list_2).data)
from linked_list import LinkedList, Node
def show_all(ll):
ll.reset()
for i in range(0,ll.size):
n = ll.current
print "position %d element %s" % (i, str(n.e))
ll.next_()
ll = LinkedList()
ll.add_e('q')
ll.add_e('w')
ll.add_e('e')
ll.add_e('r')
ll.add_e('t')
node = Node('y')
ll.add_node(node)
show_all(ll)
def test_remove_repeated_wihtout_buffer(self):
ll = LinkedList()
ll.add_node(10)
ll.add_node(8)
ll.add_node(12)
ll.add_node(8)
self.assertEqual('8->12->8->10->',ll.show_elements())
ll.remove_repeated_without_buffer()
self.assertEqual('12->8->10->',ll.show_elements())
ll.add_node(10)
ll.add_node(12)
ll.add_node(3)
ll.remove_repeated_without_buffer()
self.assertEqual('3->12->8->10->',ll.show_elements())
def test_linked_list(self):
"""
Тестовый случай, в создаётся связный список со множественными дуб-
ликатами.
"""
letters = LinkedList()
letters.add_node(Node('A'))
letters.add_node(Node('B'))
letters.add_node(Node('B'))
letters.add_node(Node('A'))
letters.add_node(Node('A'))
letters.add_node(Node('A'))
letters.add_node(Node('C'))
letters.add_node(Node('C'))
letters.add_node(Node('C'))
letters.add_node(Node('D'))
letters.add_node(Node('D'))
letters.add_node(Node('A'))
result_list = [item.data for item in remove_duplicates(letters)]
self.assertEqual(result_list, ['A', 'B', 'C', 'D'])
def test_add_negative(self):
ll = LinkedList()
for i in range(5) + [-10, -1, 0, 1]: ll.add_node(i)
assert_equals([-10, -1, 0, 0, 1, 1, 2, 3, 4], [x for x in ll.walk()])
def populate_liste(n): ll = LinkedList() for i in str(n): ll.add_node(i) return ll
def find_cycle_start(ll):
slow = ll.first_node
fast = ll.first_node
node_finder = ll.first_node
while True:
slow = slow.next
fast = fast.next.next
if slow == fast:
break
while slow != node_finder:
slow = slow.next
node_finder = node_finder.next
return node_finder.data
ll1 = LinkedList()
ll1.add_node('A')
ll1.add_node('B')
ll1.add_node('A')
ll1.add_node('B')
ll1.add_node('C')
cycle_node = ll1.last_node
ll1.add_node('D')
ll1.add_node('E')
ll1.add_node('D')
ll1.add_node('E')
ll1.add_node('D')
ll1.add_node('E')
ll1.add_node('D')
ll1.add_node('E')
ll1.add_node('D')
ll1.add_node('E')
