def test_full_linked_list_deep_equality():
ll1 = LinkedList()
ll2 = LinkedList()
ll1.append(0)
ll1.insert(1)
ll2.insert(0)
assert ll1.head.next_.val == ll2.head.val
def test_ll_append2():
linkedlist = LinkedList()
linkedlist.insert(0)
linkedlist.append(1)
linkedlist.insert(2)
linkedlist.append(3)
assert str(linkedlist) == "{ 2 } -> { 0 } -> { 1 } -> { 3 } -> NULL"
def test_add_to_list(self):
name = "Dust"
matric = "1234"
year = 3
node = Node(matric, name, year)
linked_list = LinkedList()
linked_list.add_to_list(node)
self.assertEqual(linked_list.get_root(), node)
def test_kth_from_end2s():
ll = LinkedList()
ll.insert(0)
ll.insert(1)
ll.insert(2)
ll.insert(3)
ll.insert(4)
ll.insert(5)
assert ll.kth_from_end(3) == 2
def test_ll_insert_before5():
ll = LinkedList()
ll.append(5)
ll.append(3)
ll.append(1)
with pytest.raises(Exception):
ll.insert_before(7, 10)
def test_add_many_to_list(self):
names = ("James", "1234", 10), ("Kobe", "3456", 20), ("Curry", "7890",
8)
nodes = [Node(matric, name, year) for name, matric, year in names]
linked_list = LinkedList()
for node in nodes:
linked_list.add_to_list(node)
marker = linked_list.get_root()
for i in range(len(nodes) - 1, -1, -1):
self.assertEqual(nodes[i], marker)
marker = marker.get_next()
def test_insert_after2():
ll = LinkedList()
ll.insert(0)
ll.insert(1)
ll.insert(2)
ll.insert_after(0, 5)
assert str(ll) == "{ 2 } -> { 1 } -> { 0 } -> { 5 } -> NULL"
def test_ll_insert_before4():
ll = LinkedList()
ll.append(5)
ll.append(3)
ll.append(1)
ll.insert_before(5, 10)
assert str(ll) == "{ 10 } -> { 5 } -> { 3 } -> { 1 } -> NULL"
def test_PutElements_ExpectCorrectCount(self):
# arrange
batch_size = 10
linked_list = LinkedList()
# act
for i in range(1, batch_size + 1):
new_node = DecoratedNode(i, i * 10)
linked_list.add_node(new_node)
print(linked_list)
# assert
self.assertEqual(batch_size, linked_list.NodeCount)
def obtain_list():
"""
Creates linked list of a given batch size.
:return: Returns a linked list which contains of key 1 to batch_size and values which are 1
"""
timer_start = datetime.now()
linked_list = LinkedList()
for i in range(1, batch_size + 1):
new_node = DecoratedNode(i, 1)
linked_list.add_node(new_node)
timer_end = datetime.now()
print("[ LL TIME ] Linked list creation finished in " +
str(timer_end - timer_start))
return linked_list
def handle_linked_random(size):
linked_list = LinkedList()
array = fill_random(size)
times = measure_time(array, linked_list)
print('LL, append, {} size, random, {} s'.format(
size, round(times['append'] / size, 5)))
print('LL, find, {} size, random, {} s'.format(
size, round(times['find'] / size, 5)))
def test_PutElements_ExpectThemToBePresent(self):
# arrange
batch_size = 10
linked_list = LinkedList()
original_descriptions = []
# act
for i in range(1, batch_size + 1):
new_node = DecoratedNode(i, i * 10)
original_descriptions.append(new_node.__str__())
linked_list.add_node(new_node)
resulting_descriptions = linked_list.__str__().split(', ')
# assert
for resulting_description in resulting_descriptions:
self.assertIn(resulting_description, original_descriptions)
class UnsafeHashTable:
def __init__(self):
self.first_bucket = LinkedList()
self.second_bucket = LinkedList()
self.third_bucket = LinkedList()
self.Sum = 0
self.NodeCount = 0
def add(self, key, value):
node = DecoratedNode(key, value)
bucket_number = node.key % 3
if bucket_number == 1:
self.first_bucket.add_node(node)
self.NodeCount += 1
return
if bucket_number == 2:
self.NodeCount += 1
self.second_bucket.add_node(node)
return
if bucket_number == 0:
self.NodeCount += 1
self.third_bucket.add_node(node)
return
raise ValueError(
"[ ERROR ] Adding Node to the HashTable failed - impossible index: "
+ str(bucket_number))
def get(self, key: int):
bucket_number = key % 3
if bucket_number == 1:
result = self.first_bucket.find_node(key)
return result
if bucket_number == 2:
result = self.second_bucket.find_node(key)
return result
if bucket_number == 0:
result = self.third_bucket.find_node(key)
return result
class LinkedQueue:
def __init__(self):
self.__linked_list = LinkedList()
def get_root(self):
return self.__linked_list.get_root()
def push(self, node):
self.__linked_list.add_to_list(node)
def pop(self):
marker = self.__linked_list.get_root()
if marker is None:
raise BaseException("Nothing to be pop!")
while marker.get_next():
if marker.get_next().get_next() is None:
pop_node = marker.get_next()
marker.set_next(None)
return pop_node
marker = marker.get_next()
return self.__linked_list.clear_list()
def print_queue(self):
self.__linked_list.print_list()
def get_size(self):
marker = self.__linked_list.get_root()
count = 0
while marker:
count += 1
marker = marker.get_next()
return count
def find(self, name):
return self.__linked_list.find(name)
def test_ll_merge_one_empty_list():
ll1 = LinkedList()
ll1.append(0)
ll2 = LinkedList()
mergedLists = LinkedList.merge_lls(ll2, ll1)
assert str(mergedLists) == "{ 0 } -> NULL"
def test_list_creation(self):
linked_list = LinkedList()
self.assertIsNone(linked_list.get_root())
def __init__(self):
self.first_bucket = LinkedList()
self.second_bucket = LinkedList()
self.third_bucket = LinkedList()
self.Sum = 0
self.NodeCount = 0
from linked_list.node import Node
from linked_list.LinkedList import LinkedList
nba_menber = LinkedList()
nba_menber.add_to_list(Node('aa', 'Kobe', 40))
nba_menber.add_to_list(Node('aa', 'James', 35))
nba_menber.add_to_list(Node('aa', 'Curry', 31))
nba_menber.add_to_list(Node('aa', 'Durant', 30))
nba_menber.add_to_list(Node('aa', 'Kwaii', 28))
# nba_menber.print_list()
nba_menber.find("James").print_details()
def test_ll_string2():
linklist = LinkedList()
linklist.insert(0)
linklist.insert(1)
llstring = str(linklist)
assert llstring == "{ 1 } -> { 0 } -> NULL"
def __init__(self):
self.__linked_list = LinkedList()
def test_insert_into_ll2():
linklist = LinkedList()
linklist.insert(1)
linklist.insert(5)
assert linklist.head.val == 5
def test_includes_ll():
linklist = LinkedList()
assert linklist.includes(5) == False
def test_ll_append1():
linkedlist = LinkedList()
linkedlist.insert(0)
linkedlist.append(1)
assert str(linkedlist) == "{ 0 } -> { 1 } -> NULL"
def test_ll_repr2():
linklist = LinkedList()
linklist.insert(0)
linklist.insert(1)
llstring = repr(linklist)
assert llstring == "[1, 0]"
def test_ll_merge_empty_lists():
ll1 = LinkedList()
ll2 = LinkedList()
mergedLists = LinkedList.merge_lls(ll2, ll1)
assert str(mergedLists) == "NULL"
def test_LinkedList_takes_node():
node1 = Node(1)
ll1 = LinkedList()
assert 1 == 1
def test_find_missing_in_list(self):
linked_list = LinkedList()
with self.assertRaises(LookupError):
linked_list.find("Dust")
next_reversed_half = reversed_half.next
temp = h.next
h.next = reversed_half
reversed_half.next = temp
reversed_half = next_reversed_half
h = temp
if __name__ == "__main__":
###################################################################################################################
###################################################################################################################
############################################ REVERSE SINGLY LINKED LIST 206 #######################################
###################################################################################################################
###################################################################################################################
s = Solution()
ll = LinkedList([1, 2, 3, 4, 5])
head = s.reverseList(ll.root)
ll.print_list(head)
###################################################################################################################
###################################################################################################################
############################################ HAS CYCLE 141 ########################################################
###################################################################################################################
###################################################################################################################
ll = LinkedList([1])
print(s.hasCycle(ll.root))
###################################################################################################################
###################################################################################################################
############################################ MERGE TWO SORTED LISTS 21 ############################################
def test_ll_append3():
linkedlist = LinkedList()
linkedlist.append(1)
assert linkedlist.head.val == 1
def test_includes2_ll():
linklist = LinkedList()
linklist.insert(0)
assert linklist.includes(0) == True