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())
Beispiel #3
0
 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)
Beispiel #4
0
 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))
Beispiel #7
0
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
Beispiel #8
0
 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])
Beispiel #9
0
 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())
Beispiel #11
0
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
Beispiel #12
0
 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')
Beispiel #13
0
 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'])
Beispiel #14
0
    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])
Beispiel #15
0
 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)
Beispiel #16
0
 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())
Beispiel #18
0
 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()])
Beispiel #19
0
 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()])
Beispiel #20
0
 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)
Beispiel #22
0
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())
Beispiel #24
0
 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'])
Beispiel #25
0
 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
Beispiel #27
0
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')