def partition(ll, x):
first_head = first_tail = Node()
mid_head = mid_tail = Node()
last_head = last_tail = Node()
current = ll.head
while current:
if current.value == x:
mid_tail.next = current
mid_tail = current
elif current.value < x:
first_tail.next = current
first_tail = current
else:
last_tail.next = current
last_tail = current
current = current.next
last_tail.next = None
mid_tail.next = last_head.next
first_tail.next = mid_head.next
ll.head = first_head.next
def test_len(self):
ll = LinkedList2()
ll.add_in_tail(Node(12))
ll.add_in_tail(Node(55))
ll.add_in_tail(Node(12))
self.assertEqual(ll.len(), 3)
ll.delete(12, True)
self.assertEqual(ll.len(), 1)
def test_find_all(self):
# поиск значения
NODE_VAL = 12
nodes = self.linked_list.find_all(NODE_VAL)
self.assertEqual(len(nodes), 2)
for node in nodes:
self.assertEqual(node.value, NODE_VAL)
# поиск по "сложному" типу данных
NODE_VAL = ['test', 12]
self.linked_list.add_in_tail(Node(NODE_VAL))
nodes = self.linked_list.find_all(NODE_VAL)
self.assertEqual(len(nodes), 1)
for node in nodes:
self.assertEqual(node.value, NODE_VAL)
# поиск несуществующего значения
NODE_VAL = 120
nodes = self.linked_list.find_all(NODE_VAL)
self.assertEqual(len(nodes), 0)
# получение всех узлов списка
nodes = self.linked_list.find_all()
self.assertEqual(len(nodes), 4)
# поиск по None
NODE_VAL = None
nodes = self.linked_list.find_all(NODE_VAL)
self.assertEqual(len(nodes), 4)
# поиск по нулевому значению
NODE_VAL = 0
self.linked_list.add_in_tail(Node(NODE_VAL))
nodes = self.linked_list.find_all(NODE_VAL)
self.assertEqual(len(nodes), 1)
# поиск в пустом списке
linked_list = LinkedList()
nodes = linked_list.find_all(12)
self.assertEqual(len(nodes), 0)
# поиск в списке из одного узла
linked_list.add_in_tail(Node(12))
nodes = linked_list.find_all(12)
self.assertEqual(len(nodes), 1)
for node in nodes:
self.assertEqual(node.value, 12)
nodes = linked_list.find_all(10)
self.assertEqual(len(nodes), 0)
def main():
node = Node("A")
node.next = Node("B")
node.next.next = Node("C")
node.next.next.next = Node("D")
node.next.next.next.next = Node("E")
node.next.next.next.next.next = Node("F")
node.next.next.next.next.next.next = Node("G")
node.next.next.next.next.next.next.next = node.next.next.next
node2 = loop_detection(node)
print(node2.data)
def test_add_in_tail(self):
ll = LinkedList2()
ll.add_in_tail(Node(128))
self.assertEqual(ll.tail.value, 128)
ll.add_in_tail(Node(None))
self.assertEqual(ll.tail.value, None)
ll.add_in_tail(Node('text'))
self.assertEqual(ll.tail.value, 'text')
NODE_VAL = ['test', 12]
ll.add_in_tail(Node(NODE_VAL))
self.assertEqual(ll.tail.value, NODE_VAL)
def push(self, data):
n = Node(data)
if self.head == None:
self.head = n
if self.tail != None:
self.tail.next = n
self.tail = n
def test_one_odd_node(self):
node = Node(3)
one_odd_list = LinkedList()
one_odd_list.add_node(node)
one_odd_list.remove_odds()
"it should produce and empty list has only one node, which is odd"
self.assertTrue(one_odd_list.is_empty())
def test_all_even(self):
all_even = LinkedList()
node_vals = [2, 4, 6]
for node_val in node_vals:
all_even.add_node(Node(node_val))
all_even.remove_odds()
"It should not remove any nodes if all nodes are even"
self.assertEqual(all_even.get_length(), 3)
def test_print_all_nodes(self):
import io
from contextlib import redirect_stdout
ll = LinkedList2()
ll.add_in_tail(Node(12))
ll.add_in_tail(Node(55))
ll.add_in_tail(Node(12))
f = io.StringIO()
with redirect_stdout(f):
ll.print_all_nodes()
actual = f.getvalue()
expected = "12\n55\n12\n"
self.assertEqual(actual, expected)
def main(): node = Node(5) head = node node.next = Node(3) node.next.next = None temp = Node(5) head2 = temp temp.next = Node(8) print(temp.data) print(node.data) node.data = 3 print(temp.data) print(node.data)
def test_tail_even(self):
even_tail = LinkedList()
node_vals = [2, 3, 4, 10]
for node_val in node_vals:
even_tail.add_node(Node(node_val))
even_tail.remove_odds()
"it should remove odds if the tail is even and the head is even"
self.assertEqual(even_tail.tail.data, 10)
self.assertEqual(even_tail.get_length(), 3)
def test_tail_odd(self):
odd_tail = LinkedList()
node_vals = [2, 3, 4, 5]
for node_val in node_vals:
odd_tail.add_node(Node(node_val))
odd_tail.remove_odds()
"it should remove the tail if the tail is odd and the head is even"
self.assertEqual(odd_tail.tail.data, 4)
self.assertEqual(odd_tail.get_length(), 2)
def test_head_odd(self):
odd_head = LinkedList()
node_vals = [3, 4, 5, 6]
for node_val in node_vals:
odd_head.add_node(Node(node_val))
odd_head.remove_odds()
"it should remove odds when the head node is odd and the tail is even"
self.assertEqual(odd_head.head.data, 4)
self.assertEqual(odd_head.get_length(), 2)
self.assertEqual(odd_head.tail.data, 6)
def test_add_in_tail(self):
NODE_VAL = 128
self.linked_list.add_in_tail(Node(NODE_VAL))
node = self.linked_list.tail
self.assertEqual(node.value, NODE_VAL)
NODE_VAL = None
self.linked_list.add_in_tail(Node(NODE_VAL))
node = self.linked_list.tail
self.assertEqual(node.value, NODE_VAL)
NODE_VAL = 'text'
self.linked_list.add_in_tail(Node(NODE_VAL))
node = self.linked_list.tail
self.assertEqual(node.value, NODE_VAL)
NODE_VAL = ['test', 12]
self.linked_list.add_in_tail(Node(NODE_VAL))
node = self.linked_list.tail
self.assertEqual(node.value, NODE_VAL)
def test_all_odd(self):
all_odd = LinkedList()
node_vals = [1, 3, 5, 7]
for node_val in node_vals:
all_odd.add_node(Node(node_val))
all_odd.remove_odds()
"it should remove all nodes if all nodes are odd"
self.assertEqual(all_odd.get_length(), 0)
self.assertEqual(all_odd.head, None)
self.assertEqual(all_odd.tail, None)
def test_find(self):
# поиск значения
NODE_VAL = 12
node = self.linked_list.find(NODE_VAL)
self.assertEqual(node.value, NODE_VAL)
# поиск несуществующего значения
NODE_VAL = 128
node = self.linked_list.find(NODE_VAL)
self.assertIsNone(node)
# поиск по None
NODE_VAL = None
self.linked_list.add_in_tail(Node(NODE_VAL))
node = self.linked_list.find(NODE_VAL)
self.assertEqual(node.value, NODE_VAL)
# поиск по "сложному" типу данных
NODE_VAL = ['test', 12]
self.linked_list.add_in_tail(Node(NODE_VAL))
node = self.linked_list.find(NODE_VAL)
self.assertEqual(node.value, NODE_VAL)
# поиск по нулевому значению
NODE_VAL = 0
self.linked_list.add_in_tail(Node(NODE_VAL))
node = self.linked_list.find(NODE_VAL)
self.assertEqual(node.value, NODE_VAL)
# поиск в пустом списке
linked_list = LinkedList()
node = linked_list.find(12)
self.assertIsNone(node)
# поиск в списке из одного узла
linked_list.add_in_tail(Node(12))
node = linked_list.find(12)
self.assertEqual(node.value, 12)
node = linked_list.find(10)
self.assertIsNone(node)
def __init__(self, *args, **kwargs):
n1 = Node(12)
n2 = Node(55)
n3 = Node(12)
n1.next = n2
n2.next = n3
self.linked_list = LinkedList()
self.linked_list.head = n1
self.linked_list.tail = n3
super(TestLinkedListMethods, self).__init__(*args, **kwargs)
def test_clean(self):
ll = LinkedList2()
n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
ll.add_in_tail(n1)
ll.add_in_tail(n2)
ll.add_in_tail(n3)
ll.clean()
self.assertIsNone(ll.head)
self.assertIsNone(ll.tail)
self.assertEqual(ll.len(), 0)
self.assertIsNone(n1.next)
self.assertIsNone(n2.next)
self.assertIsNone(n3.next)
self.assertIsNone(n1.prev)
self.assertIsNone(n2.prev)
self.assertIsNone(n3.prev)
def test_find_all(self):
ll = LinkedList2()
ll.add_in_tail(Node(12))
ll.add_in_tail(Node(55))
ll.add_in_tail(Node(12))
# поиск значения
nodes = ll.find_all(12)
self.assertEqual(len(nodes), 2)
for node in nodes:
self.assertEqual(node.value, 12)
# поиск по "сложному" типу данных
NODE_VAL = ['test', 12]
ll.add_in_tail(Node(NODE_VAL))
nodes = ll.find_all(NODE_VAL)
self.assertEqual(len(nodes), 1)
for node in nodes:
self.assertEqual(node.value, NODE_VAL)
# поиск несуществующего значения
nodes = ll.find_all(120)
self.assertEqual(len(nodes), 0)
# получение всех узлов списка
nodes = ll.find_all()
self.assertEqual(len(nodes), 4)
# поиск по None
nodes = ll.find_all(None)
self.assertEqual(len(nodes), 4)
# поиск по нулевому значению
ll.add_in_tail(Node(0))
nodes = ll.find_all(0)
self.assertEqual(len(nodes), 1)
# поиск в пустом списке
ll = LinkedList2()
nodes = ll.find_all(12)
self.assertEqual(len(nodes), 0)
# поиск в списке из одного узла
ll.add_in_tail(Node(12))
nodes = ll.find_all(12)
self.assertEqual(len(nodes), 1)
for node in nodes:
self.assertEqual(node.value, 12)
# поиск в списке из одного узла несуществующего элемента
nodes = ll.find_all(10)
self.assertEqual(len(nodes), 0)
def set(self, key, data):
if (key == None or data == None):
return
if (self.dictionary.has_key(key)):
node = self.dictionary[key]
node.Value = data
self.ll.remove(node)
self.ll.addToFront(node)
self.dictionary[key] = node
else:
if (self.ll.size == self.maxCount):
node = self.ll.removeFromEnd()
del self.dictionary[node.key]
node = Node(key, data)
self.ll.addToFront(node)
self.dictionary[key] = node
def test_add_in_head(self):
# вставка в список со многими элементами
ll = LinkedList2()
ll.add_in_tail(Node(1))
ll.add_in_tail(Node(2))
ll.add_in_tail(Node(3))
ll.add_in_head(Node(1200))
self.assertEqual(ll.len(), 4)
self.assertEqual(ll.head.value, 1200)
self.assertEqual(ll.head.next.value, 1)
self.assertEqual(ll.tail.value, 3)
self.assertEqual(ll.tail.prev.value, 2)
# вставка в список отличного от типа Node элемента
ll.add_in_head(1200)
self.assertEqual(ll.len(), 4)
self.assertEqual(ll.head.value, 1200)
self.assertEqual(ll.head.next.value, 1)
self.assertEqual(ll.tail.value, 3)
self.assertEqual(ll.tail.prev.value, 2)
# вставка в пустой список
ll = LinkedList2()
ll.add_in_head(Node(1200))
self.assertEqual(ll.len(), 1)
self.assertEqual(ll.head.value, 1200)
self.assertEqual(ll.tail.value, 1200)
self.assertIsNone(ll.head.prev)
self.assertIsNone(ll.head.next)
self.assertIsNone(ll.tail.prev)
self.assertIsNone(ll.tail.next)
# вставка в список с одним элементом и проверка на нулевое значение
ll = LinkedList2()
ll.add_in_tail(Node(1))
node = ll.find(1)
ll.add_in_head(Node(0))
node = ll.find(0)
self.assertEqual(ll.len(), 2)
self.assertEqual(node.value, 0)
self.assertEqual(node.next.value, 1)
self.assertEqual(node.next.prev.value, 0)
self.assertEqual(ll.head.value, 0)
self.assertEqual(ll.tail.value, 1)
def test_find(self):
ll = LinkedList2()
ll.add_in_tail(Node(12))
ll.add_in_tail(Node(55))
ll.add_in_tail(Node(12))
# поиск по значению, первое совпадение
node = ll.find(12)
self.assertEqual(node.value, 12)
self.assertEqual(node.next.value, 55)
# поиск несуществующего значения
node = ll.find(128)
self.assertIsNone(node)
# поиск по None
ll.add_in_tail(Node(None))
node = ll.find(None)
self.assertEqual(node.value, None)
# поиск по "сложному" типу данных
NODE_VAL = ['test', 12]
ll.add_in_tail(Node(NODE_VAL))
node = ll.find(NODE_VAL)
self.assertEqual(node.value, NODE_VAL)
# поиск по нулевому значению
ll.add_in_tail(Node(0))
node = ll.find(0)
self.assertEqual(node.value, 0)
# поиск в пустом списке
ll = LinkedList2()
node = ll.find(12)
self.assertIsNone(node)
# поиск в списке из одного узла
ll.add_in_tail(Node(12))
node = ll.find(12)
self.assertEqual(node.value, 12)
# поиск в списке из одного узла несуществующего элемента
node = ll.find(10)
self.assertIsNone(node)
def sum_linked_lists(first: LinkedList, second: LinkedList):
if not isinstance(first, LinkedList):
raise Exception("The first argument must be of the LinkedList type.")
if not isinstance(second, LinkedList):
raise Exception("The second argument must be of the LinkedList type.")
if first.len() != second.len():
raise Exception("Lists must be the same size.")
result = LinkedList()
node1 = first.head
node2 = second.head
while node1 is not None:
if not isinstance(node1.value, int) or not isinstance(
node2.value, int):
del result
raise Exception("The list should only have numeric values.")
result.add_in_tail(Node(node1.value + node2.value))
node1 = node1.next
node2 = node2.next
return result
def main():
node2 = Node(2)
node2.next = Node(5)
node2.next.next = Node(7)
node2.next.next.next = Node(8)
node2.next.next.next.next = Node(9)
node1 = Node(2)
node1.next = Node(1)
node1.next.next = Node(8)
node1.next.next.next = Node(6)
node1.next.next.next.next = node2.next.next
node3 = ll_intersection(node1, node2)
if not node3:
print(node3)
else:
while node3:
print(node3.data)
node3 = node3.next
def test_delete(self):
ll = LinkedList2()
ll.add_in_tail(Node(12))
ll.add_in_tail(Node(55))
ll.add_in_tail(Node(12))
self.assertEqual(ll.len(), 3)
# удаление первого найденого элемента из нескольких найденных
NODE_VALUE = 12
nodes = ll.find_all(NODE_VALUE)
self.assertEqual(len(nodes), 2)
ll.delete(NODE_VALUE)
nodes = ll.find_all(NODE_VALUE)
self.assertEqual(len(nodes), 1)
self.assertEqual(ll.len(), 2)
self.assertEqual(ll.head.value, 55)
self.assertEqual(ll.tail.value, 12)
# удаление всех найденных элементов
ll.add_in_tail(Node(NODE_VALUE))
nodes = ll.find_all(NODE_VALUE)
self.assertEqual(len(nodes), 2)
ll.delete(NODE_VALUE, True)
nodes = ll.find_all(NODE_VALUE)
self.assertEqual(len(nodes), 0)
self.assertEqual(ll.len(), 1)
self.assertEqual(ll.head.value, 55)
self.assertEqual(ll.tail.value, 55)
# удаление единственного элемента в списке
ll.delete(55)
self.assertEqual(ll.len(), 0)
self.assertIsNone(ll.head)
self.assertIsNone(ll.tail)
# удаление элемента из пустого списка
self.assertEqual(ll.len(), 0)
ll.delete(55)
self.assertEqual(ll.len(), 0)
self.assertIsNone(ll.head)
self.assertIsNone(ll.tail)
# удаление элемента из списка
# после чего остается только один элемент в списке
ll.add_in_tail(Node(NODE_VALUE))
ll.add_in_tail(Node(55))
self.assertEqual(ll.len(), 2)
ll.delete(55)
self.assertEqual(ll.head.value, 12)
self.assertEqual(ll.tail.value, 12)
self.assertIsNone(ll.head.next)
self.assertIsNone(ll.tail.next)
self.assertEqual(ll.len(), 1)
ll.add_in_tail(Node(55))
self.assertEqual(ll.len(), 2)
ll.delete(NODE_VALUE)
self.assertEqual(ll.head.value, 55)
self.assertEqual(ll.tail.value, 55)
self.assertIsNone(ll.head.next)
self.assertIsNone(ll.tail.next)
self.assertEqual(ll.len(), 1)
# проверка на удаление элементов со значением 0
# и проверка связей для всех узлов в памяти
n1 = Node(0)
n2 = Node(0)
n3 = Node(1)
n4 = Node(1)
n5 = Node(2)
n6 = Node(2)
ll = LinkedList2()
ll.add_in_tail(n1)
ll.add_in_tail(n2)
ll.add_in_tail(n3)
ll.add_in_tail(n4)
ll.add_in_tail(n5)
ll.add_in_tail(n6)
self.assertEqual(ll.len(), 6)
ll.delete(1, True)
ll.delete(2, True)
ll.delete(0)
self.assertEqual(ll.head.value, 0)
self.assertEqual(ll.tail.value, 0)
self.assertIsNone(ll.head.next)
self.assertIsNone(ll.tail.next)
self.assertEqual(ll.len(), 1)
self.assertIsNone(n1.next)
self.assertIsNone(n2.next)
self.assertIsNone(n3.next)
self.assertIsNone(n4.next)
self.assertIsNone(n5.next)
self.assertIsNone(n6.next)
self.assertIsNone(n1.prev)
self.assertIsNone(n2.prev)
self.assertIsNone(n3.prev)
self.assertIsNone(n4.prev)
self.assertIsNone(n5.prev)
self.assertIsNone(n6.prev)
#sum two numbers given as linked lists
from ll import Node
import copy
num1 = raw_input("Enter the first number: ")
num2 = raw_input("Enter the second number: ")
numA = None
for x in num1:
temp = Node(int(x))
temp.next = numA
numA = temp
numB = None
for x in num2:
temp = Node(int(x))
temp.next = numB
numB = temp
carry = 0
sum = None
curA = numA
curB = numB
while(curA != None or curB != None):
if curA == None:
Aval = 0
Bval = curB.data
curB = curB.next
def test_insert(self):
# вставка в список со многими элементами в конец списка
ll = LinkedList2()
ll.add_in_tail(Node(12))
ll.add_in_tail(Node(55))
ll.add_in_tail(Node(12))
ll.insert(None, Node(1200))
self.assertEqual(ll.head.value, 12)
self.assertEqual(ll.head.next.value, 55)
self.assertEqual(ll.len(), 4)
self.assertEqual(ll.tail.value, 1200)
self.assertEqual(ll.tail.prev.value, 12)
# вставка в список со многими элементами
ll = LinkedList2()
ll.add_in_tail(Node(12))
ll.add_in_tail(Node(55))
ll.add_in_tail(Node(12))
node = ll.find(55)
ll.insert(node, Node(66))
self.assertEqual(node.next.value, 66)
self.assertEqual(node.next.prev.value, 55)
self.assertEqual(ll.len(), 4)
self.assertEqual(ll.head.value, 12)
self.assertEqual(ll.tail.value, 12)
# вставка в список отличного от типа Node элемента
ll.insert(node, 100)
self.assertEqual(node.next.value, 66)
self.assertEqual(node.next.prev.value, 55)
self.assertEqual(ll.len(), 4)
self.assertEqual(ll.head.value, 12)
self.assertEqual(ll.tail.value, 12)
# вставка в список после несуществующего элемента
ll = LinkedList2()
ll.add_in_tail(Node(1))
ll.add_in_tail(Node(2))
ll.add_in_tail(Node(3))
ll.insert(Node(1500), Node(100))
self.assertEqual(ll.len(), 3)
self.assertEqual(ll.head.value, 1)
self.assertEqual(ll.tail.value, 3)
# вставка в пустой список
ll = LinkedList2()
ll.insert(None, Node(100))
node = ll.find(100)
self.assertEqual(ll.len(), 1)
self.assertEqual(node.value, 100)
self.assertEqual(node.next, None)
self.assertEqual(node.prev, None)
self.assertEqual(ll.head.value, 100)
self.assertEqual(ll.tail.value, 100)
# вставка в пустой список после несуществующего элемента
ll = LinkedList2()
ll.insert(Node(10), Node(10))
self.assertEqual(ll.len(), 0)
self.assertIsNone(ll.head)
self.assertIsNone(ll.tail)
# вставка в список в конец с одним элементом
# и проверка на нулевое значение
ll = LinkedList2()
ll.add_in_tail(Node(1))
ll.insert(None, Node(0))
node = ll.find(0)
self.assertEqual(ll.len(), 2)
self.assertEqual(node.value, 0)
self.assertIsNone(node.next)
self.assertEqual(node.prev.value, 1)
self.assertEqual(ll.head.value, 1)
self.assertEqual(ll.tail.value, 0)
def test_validate_node(self):
ll = LinkedList2()
self.assertTrue(ll._validate_node(Node(123)))
self.assertFalse(ll._validate_node(123))
self.assertFalse(ll._validate_node('test'))
def test_None(self):
n = Node(None)
self.assertEqual(None, n.value)
def test_simple(self):
n = Node(15)
self.assertEqual(15, n.value)
def test_one_even_node(self):
one_even_list = LinkedList()
one_even_list.add_node(Node(2))
one_even_list.remove_odds()
"it should not change the list if the list has ony one node, which is even"
self.assertEqual(one_even_list.get_length(), 1)