def setUp(self):
self.empty_linked_list = LinkedList()
self.node_0 = ListNode('nobody exists on purpose')
self.node_1 = ListNode('nobody belongs anywhere')
self.node_2 = ListNode('everybody is gonna die')
self.node_3 = ListNode('come writing Python')
self.node_0.next = self.node_1
self.node_1.next = self.node_2
self.node_2.next = self.node_3
self.linked_list = LinkedList(self.node_0)
def test_return_kth_to_last(self):
# Test data inputs and outputs
for test_input, test_output in self.data:
self.assertEqual(return_kth_to_last(test_input[0], test_input[1]),
test_output)
# Test empty LinkedList
with self.assertRaises(Exception):
return_kth_to_last(LinkedList(), 0)
# Test k that is too large
with self.assertRaises(AttributeError):
return_kth_to_last(LinkedList(input_arr=[1, 2, 3, 4, 5]), 10)
def recursive_helper(current_node, depth, array):
"""Recursively add node to linked list that corresponds to the current
depth
Parameters
----------
current_node : Node
Node in a binary (search) tree
depth : int
Current depth in tree
array : list of LinkedList
List of linked lists, with 1 linked list per depth in tree
Returns
-------
array : list of LinkedList
Updated input list of linked lists
"""
# Break case, when leaf node is reached
if current_node is None:
return array
# Create empty linked list if required
if len(array) - 1 < depth:
array.extend([LinkedList()])
# Add node to relevant linked list
array[depth].prepend(current_node.data)
# Recursively explore left node
array = recursive_helper(current_node.left_node, depth + 1, array)
# Recursively explore right node
array = recursive_helper(current_node.right_node, depth + 1, array)
return array
def test_partition(self):
for test_input in self.data:
result = partition(test_input[0], test_input[1])
self.assertTrue(self._is_partitioned(result, test_input[1]))
# Test empty LinkedList
with self.assertRaises(Exception):
partition(LinkedList(), 3)
def __init__(self, num_elements):
"""Initialise Hash Table by creating array of length num_elements, with
each element being a linked list
Parameters
----------
num_elements : int
Size of array that stores linked lists
"""
# Create array of linked lists
self.main_array = [LinkedList() for i in range(num_elements)]
self.num_elements = num_elements
class Test(unittest.TestCase):
"""Test cases"""
# Define test case inputs, and expected outputs
data = [
((LinkedList(input_arr=[1, 2, 2, 5, 6, 2]), 2),
LinkedList(input_arr=[1, 2, 5, 6, 2])),
((LinkedList(input_arr=['a', 'b', 'c', 'd', 'e']), 3),
LinkedList(input_arr=['a', 'b', 'c', 'e'])),
]
def test_delete_middle_node(self):
for test_input, test_output in self.data:
# Find node to delete, to input into function
node_to_delete = test_input[0].head
for i in range(test_input[1]):
node_to_delete = node_to_delete.next_node
# Perform deletion
delete_middle_node(node_to_delete)
# Check resulting linked list is as expected
self.assertEqual(test_input[0].__str__(), test_output.__str__())
class Test(unittest.TestCase):
"""Test cases"""
# Define test case inputs, and expected outputs
data = [
((LinkedList(input_arr=[1, 2, 3, 4, 5]), 2), 3),
((LinkedList(input_arr=[1, 2, 3, 4, 5]), 0), 5),
((LinkedList(input_arr=[1, 2, 3, 4, 5]), 4), 1),
]
def test_return_kth_to_last(self):
# Test data inputs and outputs
for test_input, test_output in self.data:
self.assertEqual(return_kth_to_last(test_input[0], test_input[1]),
test_output)
# Test empty LinkedList
with self.assertRaises(Exception):
return_kth_to_last(LinkedList(), 0)
# Test k that is too large
with self.assertRaises(AttributeError):
return_kth_to_last(LinkedList(input_arr=[1, 2, 3, 4, 5]), 10)
def test_return_kth_to_last_v2(self):
# Test data inputs and outputs
for test_input, test_output in self.data:
self.assertEqual(
return_kth_to_last_v2(test_input[0], test_input[1]),
test_output)
# Test empty LinkedList
with self.assertRaises(Exception):
return_kth_to_last_v2(LinkedList(), 0)
# Test k that is too large
with self.assertRaises(Exception):
return_kth_to_last_v2(LinkedList(input_arr=[1, 2, 3, 4, 5]), 10)
def generate_list_of_depths(tree):
"""Given a binary tree, create a list of linked lists, where each linked
list has all of nodes at a certain depth in the tree
Parameters
----------
tree : BinarySearchTree
Tree to process
Returns
-------
array : list of LinkedList
List of linked lists, with 1 linked list per depth in tree
"""
return recursive_helper(tree.root, 0, [LinkedList()])
class Test(unittest.TestCase):
"""Test cases"""
# Define test case inputs, and expected outputs
data = [(LinkedList(input_arr=[1, 2, 2, 5, 6, 2]), 3),
(LinkedList(input_arr=[1, 2, 3, 1, 2, 3, 5]), 2),
(LinkedList(input_arr=[10, 21, 21, 56, 66, 20]), 5),
(LinkedList(input_arr=[1, 2, 3, 1, 2, 3, 5]), 20),
(LinkedList(input_arr=[1, 3]), 2),
(LinkedList(input_arr=[3, 1]), 2)]
def _is_partitioned(self, linked_list, partition_val):
"""Tests to see if linked list is partitioned properly
Parameters
----------
linked_list : LinkedList
Partitioned linked list
partition_val : any
Any object that can be stored in LinkedList, and allows comparison
Returns
-------
bool
True if linked_list is partitioned correctly, False otherwise
"""
current_node = linked_list.head
in_right_half = False # Turns to True when first element with
# value >= partition_val has been found in linked_list
# Walk through linked list, checking values
while current_node is not None:
# Note: an optimisation would be to stop performing this check once
# in_right_half is True (use separate while loop); not implemented
if current_node.data >= partition_val and not in_right_half:
in_right_half = True
if in_right_half:
if current_node.data < partition_val:
return False
# Go to next node
current_node = current_node.next_node
return True
def test_partition(self):
for test_input in self.data:
result = partition(test_input[0], test_input[1])
self.assertTrue(self._is_partitioned(result, test_input[1]))
# Test empty LinkedList
with self.assertRaises(Exception):
partition(LinkedList(), 3)
class TestCase(unittest.TestCase):
def setUp(self):
self.empty_linked_list = LinkedList()
self.node_0 = ListNode('nobody exists on purpose')
self.node_1 = ListNode('nobody belongs anywhere')
self.node_2 = ListNode('everybody is gonna die')
self.node_3 = ListNode('come writing Python')
self.node_0.next = self.node_1
self.node_1.next = self.node_2
self.node_2.next = self.node_3
self.linked_list = LinkedList(self.node_0)
def test__len__(self):
self.assertEqual(len(self.empty_linked_list), 0)
self.assertEqual(len(self.linked_list), 4)
def test__iter__(self):
self.assertEqual(list(self.empty_linked_list), [])
self.assertEqual(list(self.linked_list), [
self.node_0.value, self.node_1.value, self.node_2.value,
self.node_3.value
])
def test__getitem__(self):
with self.assertRaises(IndexError):
print(self.empty_linked_list[0])
self.assertEqual(self.linked_list[0], self.node_0.value)
self.assertEqual(self.linked_list[1], self.node_1.value)
self.assertEqual(self.linked_list[2], self.node_2.value)
self.assertEqual(self.linked_list[3], self.node_3.value)
with self.assertRaises(IndexError):
print(self.linked_list[4])
def test__setitem__(self):
with self.assertRaises(IndexError):
self.empty_linked_list[0] = 0
self.linked_list[0] = '0'
self.linked_list[1] = '1'
self.linked_list[3] = '3'
self.assertEqual(self.linked_list.head.value, '0')
self.assertEqual(self.linked_list[0], '0')
self.assertEqual(self.linked_list[1], '1')
self.assertEqual(self.linked_list[2], self.node_2.value)
self.assertEqual(self.linked_list[3], '3')
with self.assertRaises(IndexError):
self.linked_list[4] = '4'
def test_insert(self):
self.empty_linked_list.insert_before(0, '0')
self.assertEqual(self.empty_linked_list[0], '0')
self.linked_list.insert_before(0, '0')
self.linked_list.insert_before(1, '1')
self.linked_list.insert_before(3, '3')
self.linked_list.insert_before(6, '6')
self.linked_list.insert_before(8, '8')
expected = [
'0',
'1',
self.node_0.value,
'3',
self.node_1.value,
self.node_2.value,
'6',
self.node_3.value,
'8',
]
self.assertEqual(self.linked_list.head.value, '0')
self.assertEqual(list(self.linked_list), expected)
with self.assertRaises(IndexError):
self.linked_list.insert_before(10, '10')
def test_pop(self):
with self.assertRaises(IndexError):
self.empty_linked_list.pop(0)
self.assertEqual(self.linked_list.pop(0), self.node_0.value)
self.assertEqual(self.linked_list.pop(2), self.node_3.value)
expected = [
self.node_1.value,
self.node_2.value,
]
self.assertEqual(self.linked_list.head.value, self.node_1.value)
self.assertEqual(list(self.linked_list), expected)
with self.assertRaises(IndexError):
self.linked_list.pop(10)
def test_index(self):
self.assertEqual(self.linked_list.index(self.node_0.value), 0)
self.assertEqual(self.linked_list.index(self.node_1.value), 1)
self.assertEqual(self.linked_list.index(self.node_2.value), 2)
self.assertEqual(self.linked_list.index(self.node_3.value), 3)
with self.assertRaises(ValueError):
print(self.linked_list.index('NOT EXIST'))
def test_append(self):
self.empty_linked_list.append('0')
self.assertEqual(self.empty_linked_list.head.value, '0')
self.assertEqual(self.empty_linked_list[0], '0')
self.linked_list.append('4')
expected = [
self.node_0.value,
self.node_1.value,
self.node_2.value,
self.node_3.value,
'4',
]
self.assertEqual(list(self.linked_list), expected)
def test_reverse(self):
self.empty_linked_list.reverse()
self.assertEqual(list(self.empty_linked_list), [])
self.linked_list.reverse()
expected = [
self.node_3.value,
self.node_2.value,
self.node_1.value,
self.node_0.value,
]
self.assertEqual(self.linked_list.head.value, self.node_3.value)
self.assertEqual(list(self.linked_list), expected)
class Test(unittest.TestCase):
"""Test cases"""
# Define test case inputs, and expected outputs
data = [
(LinkedList(input_arr=[1, 2, 2]), LinkedList(input_arr=[1, 2])),
(LinkedList(input_arr=[1, 2, 3]), LinkedList(input_arr=[1, 2, 3])),
(LinkedList(input_arr=[1]), LinkedList(input_arr=[1])),
(
LinkedList(input_arr=['a', 'b', 'b']),
LinkedList(input_arr=['a', 'b'])
),
(
LinkedList(input_arr=list('abbacdeefaab')),
LinkedList(input_arr=list('abcdef'))
),
(LinkedList(input_arr=[]), LinkedList(input_arr=[])),
]
def test_remove_dups(self):
for test_input, test_output in self.data:
self.assertEqual(
remove_dups(test_input).__str__(), test_output.__str__()
)
def test_remove_dups_v2(self):
for test_input, test_output in self.data:
self.assertEqual(
remove_dups(test_input).__str__(), test_output.__str__()
)