def merge(list1, list2):
"""prende in input due CircularPositionalList ordinate e le fonde in una nuova CircularPositionalList ordinata"""
if not isinstance(list1, CircularPositionalList) or not isinstance(
list2, CircularPositionalList):
raise TypeError("The operands are not CircularPositionalList")
if not (list1.is_sorted() and list2.is_sorted()):
raise ValueError("The lists are not sorted")
current_first_list = list1.first()
current_second_list = list2.first()
i = e = 0
new_list = CircularPositionalList()
while i < len(list1) and e < len(list2):
if current_first_list.element() > current_second_list.element(
): # se minore l'elemento della seconda lista lo inserisco
new_list.add_last(current_second_list.element())
current_second_list = list2._next_position(current_second_list)
e += 1
else:
new_list.add_last(current_first_list.element(
)) # altrimenti inserisco quello della prima lista
current_first_list = list1._next_position(current_first_list)
i += 1
while i < len(list1):
new_list.add_last(
current_first_list.element()
) # se il contatore della prima lista non ha raggiunto la dimensione di quest'ultima allora aggiungo ancora
current_first_list = list1._next_position(current_first_list)
i += 1
while e < len(list2):
new_list.add_last(current_second_list.element())
current_second_list = list2._next_position(
current_second_list
) # lo stesso se non è stata raggiunta la dimensione della seconda
e += 1
return new_list
def test_empty_list_count():
"""
Verifica count su una lista vuota
"""
cpl = CircularPositionalList()
if cpl.count(5) == 0 and cpl.count("ppp") == 0:
print("Test test_empty_list_count passed")
else:
print("Test test_empty_list_count failed")
def test_empty_list_first():
"""
Verifica che first() su lista vuota restituisca None
"""
cpl = CircularPositionalList()
if cpl.first() is None:
print("Test test_empty_list_first passed")
else:
print("Test test_empty_list_first failed")
def test_empty_list_is_empty():
"""
Verifica che la lista sia vuota
"""
cpl = CircularPositionalList()
if cpl.Is_empty():
print("Test test_empty_list_is_empty passed")
else:
print("Test test_empty_list_is_empty failed")
def test_empty_list_last():
"""
Verifica last() su lista vuota
"""
cpl = CircularPositionalList()
if cpl.last() is None:
print("Test test_empty_list_last passed")
else:
print("Test test_empty_list_last failed")
def _insert_in_order(self, s):
if s > self._sb.last().element(): # Inserimento in testa
self._sb.add_last(s)
self._size += 1
elif self._sb.find(s) is None:
one_element_list = CircularPositionalList()
one_element_list.add_last(s)
self._sb = merge(self._sb, one_element_list)
self._size += 1
def test_empty_list_before_after():
"""
Verifica che before(p) e after(p) in caso di predecessore mancante restituiscano None
"""
cpl = CircularPositionalList()
pos = cpl.add_last(33)
if cpl.before(pos) is None and cpl.after(pos) is None:
print("Test test_empty_list_before_after passed")
else:
print("Test test_empty_list_before_after failed")
def test_empty_list_reverse():
"""
Verifica reverse su una lista vuota
"""
cpl = CircularPositionalList()
# lista vuota lancia exception AttributeError
try:
cpl.reverse()
except AttributeError:
print("Test test_empty_list_reverse passed")
return
print("Test test_empty_list_reverse failed")
def test_merge_deep_copy():
l1 = CircularPositionalList()
l2 = CircularPositionalList()
l1.add_last([2, 5, 6])
l2.add_last([66, 6, 0])
m = merge(l1, l2)
l1.first().element().append(42)
if len(m.first().element()) == 3:
print("Test test_merge_deep_copy passed")
else:
print("Test test_merge_deep_copy failed")
def test_str():
"""
Verifica l'operatore str
"""
cpl = CircularPositionalList()
_ = cpl.add_last(42)
_ = cpl.add_last(10)
_ = cpl.add_last(1)
if str(cpl) == "42, 10, 1":
print("Test test_str passed")
else:
print("Test test_str failed")
def test_find():
"""
Verifica find() con elemento presente o meno (se non presente restituisce None)
"""
cpl = CircularPositionalList()
_ = cpl.add_last(33)
_ = cpl.add_last(56)
pos1 = cpl.find(33)
pos2 = cpl.find(555)
if pos1.element() == 33 and pos2 is None:
print("Test test_find passed")
else:
print("Test test_find failed")
def test_empty_list_clear():
"""
Verifica clear su una lista vuota, non deve rilanciare eccezioni
"""
# non deve lanciare eccezioni nè restituire qualcosa
cpl = CircularPositionalList()
try:
cpl.clear()
except BaseException as e:
print(e)
print("Test test_empty_list_clear failed")
return
print("Test test_empty_list_clear passed")
def test_len():
"""
Verifica l'operatore len
"""
cpl = CircularPositionalList()
if len(cpl) == 0:
_ = cpl.add_last(42)
_ = cpl.add_last(10)
_ = cpl.add_last(1)
_ = cpl.add_last(77)
if len(cpl) == 4:
print("Test test_len passed")
else:
print("Test test_len failed")
def merge(cplist_one, cplist_two):
ret_list = CircularPositionalList()
if type(cplist_one) == type(cplist_two):
if cplist_one.is_sorted() and cplist_two.is_sorted():
if cplist_one.is_empty():
return cplist_two.copy()
if cplist_two.is_empty():
return cplist_one.copy()
if cplist_one.last().element() > cplist_two.last().element():
cplist_one, cplist_two = cplist_two, cplist_one
current = cplist_one._header._next
current2 = cplist_two._header._next
for elem in cplist_one:
while current2._element < elem:
ret_list.add_last(current2._element)
current2 = current2._next
current = current._next
ret_list.add_last(elem)
while current2._element is not None:
ret_list.add_last(current2._element)
current2 = current2._next
else:
raise Exception("Each list must be sorted!")
else:
raise TypeError("Error in lists type!")
return ret_list
def test_get_item():
"""
Verifica l'operatore di accesso x[p]
"""
cpl = CircularPositionalList()
p1 = cpl.add_last(42)
p2 = cpl.add_last(10)
p3 = cpl.add_last(1)
if cpl[p1] == 42 and cpl[p2] == 10 and cpl[p3] == 1:
try:
_ = cpl["illegal_item"]
except TypeError:
print("Test test_get_item passed")
else:
print("Test test_get_item failed")
def test_count():
"""
Verifica il conteggio di occorrenze di un elemento presente o meno
"""
cpl = CircularPositionalList()
_ = cpl.add_last(5)
_ = cpl.add_first(42)
_ = cpl.add_first(42)
_ = cpl.add_first(1)
_ = cpl.add_first(42)
_ = cpl.add_last(88)
if cpl.count(42) == 3 and cpl.count(33) == 0 and cpl.count(5) == 1:
print("Test test_count passed")
else:
print("Test test_count failed")
def test_iter():
"""
Generatore che restituisce gli elementi della lista a partire da quello che è
identificato come primo fino a quello che è identificato come ultimo
"""
cpl = CircularPositionalList()
_ = cpl.add_last(42)
_ = cpl.add_last(10)
_ = cpl.add_last(1)
support_list = list()
for f in cpl:
support_list.append(f)
if support_list[0] == 42 and support_list[2] == 1:
print("Test test_iter passed")
else:
print("Test test_iter failed")
def test_empty_list_is_sorted():
"""
Verifica se una lista vuota è ordinata
"""
# Se la lista è vuota restituisce True
cpl = CircularPositionalList()
try:
res_b = cpl.Is_sorted()
except BaseException as e:
print(e)
print("Test test_empty_list_is_sorted failed")
return
if res_b:
print("Test test_empty_list_is_sorted passed")
else:
print("Test test_empty_list_is_sorted failed")
def test_before_and_after():
"""
Verifica after(p) e before(p) nel caso nominale, sia per position interne alla lista che per gli estremi
"""
cpl = CircularPositionalList()
_ = cpl.add_last(5)
in2 = cpl.add_first(67)
first = cpl.add_first(5)
last = cpl.add_last(88)
res_before = cpl.before(first)
res_after = cpl.after(last)
in2_after = cpl.after(in2)
in2_before = cpl.before(in2)
if res_before == 88 and res_after == 5 and in2_after == 5 and in2_before == 5:
print("Test test_before_and_after passed")
else:
print("Test test_before_and_after failed")
def test_delete_existing_tail():
"""
Verifica la cancellazione dalla lista della position tail
"""
list_obj = CircularPositionalList()
pos = list_obj.add_first(7)
list_obj.add_first(9)
list_obj.add_first(3)
list_obj.add_first(10)
list_obj.delete(pos)
if str(list_obj) == "10, 3, 9":
print("Test test_delete_existing_tail passed")
else:
print("Test test_delete_existing_tail failed")
def test_first_and_last():
"""
Verifica first() e last() su lista non vuota
"""
cpl = CircularPositionalList()
_ = cpl.add_last(5)
_ = cpl.add_first(67)
_ = cpl.add_first(5)
_ = cpl.add_first(42)
_ = cpl.add_last(88)
if cpl.first().element() is 42 and cpl.last().element() is 88:
print("Test test_first_and_last passed")
else:
print("Test test_first_and_last failed")
def test_delete_existing_middle():
"""
Verifica la cancellazione dalla lista di una position generica
"""
list_obj = CircularPositionalList()
list_obj.add_first(7)
list_obj.add_first(9)
pos = list_obj.add_first(3)
list_obj.add_first(10)
list_obj.delete(pos)
if str(list_obj) == "10, 9, 7":
print("Test test_delete_existing_middle passed")
else:
print("Test test_delete_existing_middle failed")
def run_test_base():
cpl = CircularPositionalList()
position = cpl.add_last(4)
test_empty_list_is_empty()
test_full_list_is_empty()
test_empty_list_first()
test_empty_list_last()
test_empty_list_before_after()
test_after_exception()
test_before_exception()
test_add_first()
test_add_last()
test_add_before()
test_add_after()
test_wrong_position_add_before_after()
test_before_and_after()
test_first_and_last()
test_empty_list_is_sorted()
test_is_sorted()
test_replace_existing_position()
test_replace_illegal_type()
test_replace_value_error()
test_empty_list_delete(p=position)
test_empty_list_clear()
test_delete_existing_head()
test_delete_existing_middle()
test_delete_existing_tail()
test_clear()
test_empty_list_count()
test_count()
test_empty_list_reverse()
test_reverse()
test_copy()
test_find()
test_find_first_occurence()
# print('\n')
test_len()
test_in()
test_get_item()
test_set_item()
test_add()
test_del()
test_iter()
test_str()
def test_delete_existing_head():
"""
Verifica la cancellazione dalla lista della position head
"""
list_obj = CircularPositionalList()
list_obj.add_first(7)
list_obj.add_first(9)
list_obj.add_first(3)
pos = list_obj.add_first(10)
list_obj.delete(pos)
if str(list_obj) == "3, 9, 7":
print("Test test_delete_existing_head passed")
else:
print("Test test_delete_existing_head failed")
class ExternalMethodTest(unittest.TestCase):
def setUp(self):
"""Tale metodo verrà eseguito prima di ogni test"""
self._circularList1 = CircularPositionalList()
self._circularList2 = CircularPositionalList()
def test_bubblesorted(self):
for i in range(-10, 0):
self._circularList1.add_last(-i)
j = 1
for elem in bubblesorted(self._circularList1):
self.assertEqual(elem, j)
j += 1
# Verifichiamo che il generatore non ha modificato gli elementi della lista
self.assertEqual(self._circularList1.first().element(), 10)
def test_merge(self):
for i in range(10):
self._circularList1.add_last(i)
self._circularList2.add_last(i + 10)
l = merge(self._circularList1, self._circularList2)
for i in range(20):
self.assertEqual(l.delete(l.first()), i)
def test_set_item():
"""
Verifica l'operatore di modifica x[p] = e
"""
cpl = CircularPositionalList()
p1 = cpl.add_last(42)
p2 = cpl.add_last(10)
p3 = cpl.add_last(1)
try:
cpl[p1] = 2
cpl[p2] = 3
cpl[p3] = 4
except BaseException as e:
print(e)
if cpl[p1] == 2 and cpl[p2] == 3 and cpl[p3] == 4:
print("Test test_set_item passed")
else:
print("Test test_set_item failed")
def test_del():
"""
Verifica l'operatore del
"""
cpl = CircularPositionalList()
p1 = cpl.add_last(42)
p2 = cpl.add_last(10)
p3 = cpl.add_last(1)
try:
del cpl[p1]
del cpl[p2]
del cpl[p3]
except BaseException as e:
print(e)
if cpl.Is_empty():
print("Test test_del passed")
else:
print("Test test_del failed")
def test_replace_value_error():
"""
Verifica il replace con una position di un altro container
"""
list_obj = CircularPositionalList()
list_obj.add_first(9)
list_obj.add_first(3)
o = CircularPositionalList()
position = o.add_first(99)
try:
list_obj.replace(position, 100)
except ValueError:
print("Test test_replace_value_error passed")
return
print("Test test_replace_value_error failed")
def test_full_list_is_empty():
"""
Verifica che la lista non sia vuota
"""
cpl = CircularPositionalList()
cpl.add_last(42)
cpl.add_last(48)
cpl.add_last(55)
cpl.add_last(54)
cpl.add_first(13)
# print(cpl)
if not cpl.Is_empty() and str(cpl) == "13, 42, 48, 55, 54":
print("Test test_full_list_is_empty passed")
else:
print("Test test_full_list_is_empty failed")
def merge(list1, list2) -> CircularPositionalList:
"""
Implementazione dell'algoritmo di merge di due liste passate come parametri di ingresso.
Complessità computazionale O(n).
:param list1: prima lista da inserire nell'unione, preordinata
:param list2: seconda lista da inserire nell'unione, preordinata
:return list_to_return: lista risultante dall'unione, preservando l'ordinamento e la dimensione massima della prima lista
"""
# Precondizione liste ordinate, controllare solo se le liste sono ordinate
if list1.Is_empty() and list2.Is_empty(
): # Controllo se la lista1 è vuota e se la lista2 è ordinata
raise ValueError('both lists are empty')
elif list1.Is_empty():
return list2
elif list2.Is_empty(
): # Controllo se la lista2 è vuota e se la lista1 è ordinata
return list1
else:
index1 = 0
index2 = 0
list_to_return = CircularPositionalList()
node1 = list1.first()
node2 = list2.first()
while index2 < len(list2) and index1 < len(list1):
if list1[node1] >= list2[node2]:
list_to_return.add_last(copy.deepcopy(list2[node2]))
node2 = list2._after(node2)
index2 += 1
else:
list_to_return.add_last(copy.deepcopy(list1[node1]))
node1 = list1._after(node1)
index1 += 1
while index2 < len(list2):
list_to_return.add_last(copy.deepcopy(list2[node2]))
node2 = list2._after(node2)
index2 += 1
while index1 < len(list1):
list_to_return.add_last(copy.deepcopy(list1[node1]))
node1 = list1._after(node1)
index1 += 1
return list_to_return