def test_value_n_from_end():
l = SingleLinkedList()
for i in range(10):
l.push_back(i)
assert l.value_n_from_end(0) == 9
assert l.value_n_from_end(3) == 6
def test_seq_constructor():
l = SingleLinkedList([0, 1, 2, 3, 4])
assert l.length == 5
for i in range(5):
assert i == l.pop_front()
def test_push_back_second():
l = SingleLinkedList()
for i in range(5):
l.push_back(i)
assert l.tail.data == 4
assert l.head.data == 0
def merge_sorted_lists():
k = 10
n = 10
min_value = 0
max_value = 30
sorted_lists = generate_sorted_lists(k,n,min_value,max_value)
sorted_list = SingleLinkedList()
heap = MinHeap([], 0)
# fill in the 1st batch
for i, l in sorted_lists.items():
heap.add(IdAndValue(i, l.pop(0)))
while len(sorted_lists) > 0:
item = heap.pop()
sorted_list.append(item.get_value())
list_id = item.get_id()
if list_id in sorted_lists:
value = sorted_lists[list_id].pop(0)
if len(sorted_lists[list_id]) <= 0:
sorted_lists.pop(list_id)
heap.add(IdAndValue(list_id, value))
else:
list_id, list = sorted_lists.items()[0]
heap.add(IdAndValue(list_id, list.pop(0)))
if len(list) <= 0:
sorted_lists.pop(list_id)
while not heap.is_empty():
sorted_list.append(heap.pop())
print k*n, len(sorted_list), sorted_list
def test_get_by_index(self):
count = 10
l = SingleLinkedList(100 * i for i in range(count))
indices = list(range(count))
random.shuffle(indices)
for random_index in indices:
value = l.get_n_th_node(random_index).value
self.assertEqual(100 * random_index, value)
def test_front():
l = SingleLinkedList()
for i in range(10):
l.push_back(i)
assert 0 == l.front()
l = SingleLinkedList()
for i in range(10):
l.push_front(i)
assert i == l.front()
def add(self, key, value):
index = self._get_hash_key(key)
if (self._hash_table[index]):
# Need to check for duplicate keys
# Overwrite value for existing key
self._hash_table[index].add_rear(key, value)
else:
hash_bucket = SingleLinkedList()
hash_bucket.add_rear(key, value)
self._hash_table[index] = hash_bucket
def test_exceptions(self):
l1 = SingleLinkedList([1])
l2 = SingleLinkedList([1])
l1_node = l1.get_n_th_node(0)
self.assertRaises(NodeIsUnreachableError,
l2.insert_before, l1_node, 3)
self.assertRaises(InvalidPositionError,
l1.insert_at_position, 100, 100)
self.assertRaises(InvalidPositionError,
l1.get_n_th_node, 1)
def test_insert_after(self):
l = SingleLinkedList([1])
node = l.get_n_th_node(0)
l.insert_after(node, 2)
self._check_list(l, (1, 2))
l.insert_after(node, 3)
self._check_list(l, (1, 3, 2))
l.insert_after(l.get_n_th_node(2), 7)
self._check_list(l, (1, 3, 2, 7))
def test_erase_tail():
l = SingleLinkedList()
l.push_back(1)
assert l.tail.data == 1
l.push_back(2)
assert l.tail.data == 2
l.push_back(3)
assert l.tail.data == 3
l.erase(2)
assert l.tail.data == 2
class Stack:
def __init__(self):
self._sll = SingleLinkedList()
def push(self, value):
node = Node(value)
self._sll.insert(node, pos=0)
def pop(self):
if self._sll.isEmpty():
raise Exception("Empty Stack")
node = self._sll.head
self._sll.head = self._sll.head.next
return node.value
class Queue:
def __init__(self):
self._sll = SingleLinkedList()
def enqueue(self, value):
node = Node(value)
self._sll.append(node)
def dequeue(self):
if self._sll.isEmpty():
raise Exception("Empty Queue")
v = self._sll.head
self._sll.head = self._sll.head.next
return v.value
def test_insert_before_by_reordering(self):
l = SingleLinkedList([1])
node = l.get_n_th_node(0)
l.insert_before_by_reordering(node, 3)
self._check_list(l, (3, 1))
l.insert_before_by_reordering(node, 5)
self._check_list(l, (5, 3, 1))
node = l.get_n_th_node(2)
node = l.insert_before_by_reordering(node, 8)
self._check_list(l, (5, 3, 8, 1))
node = l.insert_before_by_reordering(node, 6)
self._check_list(l, (5, 3, 8, 6, 1))
def topo_sort_by_dfs(dg: DirectedGraph):
adj = dg.adj
vertex_nums = len(adj)
visited = [False] * vertex_nums
reverse_adj = [SingleLinkedList() for _ in range(vertex_nums)]
# 构造逆邻接表
for i in range(vertex_nums):
v = adj[i].head
while v:
if v.val is None: break
id_ = v.val[0]
reverse_adj[id_].append((i, 1))
v = v._next
def dfs(i):
v = reverse_adj[i].head
while v:
if v.val is None or visited[v.val[0]]: break
id_ = v.val[0]
visited[id_] = True
dfs(id_)
v = v._next
print(i)
# 遍历
for i in range(vertex_nums):
if visited[i]: continue
visited[i] = True
dfs(i)
def test_erase_middle():
l = SingleLinkedList()
l.push_back(1)
l.push_back(2)
l.push_back(3)
assert l.head.next.data == 2
l.erase(1)
assert l.head.next.data == 3
def test_pop_back():
l = SingleLinkedList()
l.push_back(1)
assert l.head.data == 1
assert l.tail.data == 1
l.push_back(2)
assert l.head.data == 1
assert l.tail.data == 2
l.push_back(3)
assert l.head.data == 1
assert l.tail.data == 3
assert l.pop_back(), 3
assert l.pop_back(), 2
assert l.pop_back(), 1
class SingleLinkedSet:
""" Data structure for storing only unique values.
Not thread-safe.
"""
def __init__(self, iterable=None):
self._container = SingleLinkedList()
if iterable:
for item in iterable:
self.add(item)
def add(self, value):
if not self._container.contains(value):
self._container.append(value)
def contains(self, value):
return self._container.contains(value)
def __contains__(self, value):
return self.contains(value)
def test_push_back():
l = SingleLinkedList()
l.push_back(1)
assert l.tail.data == 1
assert l.head.data == 1
l.push_back(2)
assert l.tail.data == 2
assert l.head.data == 1
assert l.head.next.data == l.tail.data
l.push_back(3)
assert l.tail.data == 3
assert l.head.next.next.data == 3
def test_push_front():
l = SingleLinkedList()
l.push_front(1)
assert l.head.data == 1
assert l.tail.data == 1
l.push_front(2)
assert l.head.data == 2
assert l.tail.data == 1
assert l.head.next.data, l.tail.data
l.push_front(3)
assert l.head.data == 3
assert l.head.next.data == 2
def test_erase_head():
l = SingleLinkedList()
l.push_front(1)
assert l.head.data == 1
l.erase(0)
assert l.head == None
def test_remove_value_middle():
l = SingleLinkedList()
for i in range(5):
l.push_back(i)
l.remove_value(2)
assert l.head.next.next.data == 3
def test_value_at():
l = SingleLinkedList()
for i in range(5):
l.push_back(i)
assert l.value_at(0) == 0
assert l.value_at(2) == 2
assert l.value_at(4) == 4
def test_remove_value_back():
l = SingleLinkedList()
for i in range(5):
l.push_back(i)
l.remove_value(4)
assert l.tail.data == 3
def test_insert_first_element_to_empty_list(self):
l = SingleLinkedList()
l.insert_at_position(0, 'D')
self._check_is_single_element_list(l)
l = SingleLinkedList()
l.insert_at_position(-1, 'D')
self._check_is_single_element_list(l)
def test_remove_value_front():
l = SingleLinkedList()
for i in range(5):
l.push_back(i)
l.remove_value(0)
assert l.head.data == 1
class SingleLinkedStack0:
def __init__(self):
self.items = SingleLinkedList()
self.length = 0
def push(self, item):
self.items.append(item)
self.length += 1
return True
def pop(self):
if len(self.items) == 0:
return None
return self.items.pop(self.length - 1)
def __len__(self):
return len(self.items)
def __repr__(self):
"""
显示栈的容量
"""
return "<SingleLinkedStack0: %d>" % self.length
def test_insert_tail():
l = SingleLinkedList()
for i in range(5):
l.push_back(i)
l.insert(4, 33)
assert l.tail.data == 33
assert l.length == 6
def test_reverse():
l = SingleLinkedList()
for i in range(5):
l.push_front(i)
l.reverse()
assert l.head.data == 0
assert l.tail.data == 4
assert l.tail.next == None
for i in range(5):
assert l.pop_front() == i
def is_palindrome1(single_linked):
# 如果回文串长度为 0 或 1 则为回文串
if single_linked.length in [0, 1]:
return True
fast, slow = single_linked.head, single_linked.head
# 寻找中间节点
while fast._next and fast._next._next:
slow = slow._next
fast = fast._next._next
# 后半部分逆序
prev = slow._next
if not prev._next:
second_part = SingleLinkedList(prev)
else:
current = prev._next
after = prev._next._next
prev._next = None
while True:
current._next = prev
prev = current
current = after
if not current:
second_part = SingleLinkedList(prev)
break
else:
after = current._next
# 判断是否是回文串
node1 = single_linked.head
node2 = second_part.head
while node2:
if node1.val != node2.val:
return False
else:
node1 = node1._next
node2 = node2._next
return True
def test_instert_head():
l = SingleLinkedList()
for i in range(5):
l.push_back(i)
assert l.head.data == 0
assert l.tail.data == 4
l.insert(0, 33)
assert l.head.data == 33
def test_insert_middle():
l = SingleLinkedList()
for i in range(10):
l.push_back(i)
l.insert(3, 99)
assert l.head.next.next.next.data == 99
assert l.head.next.next.next.next.data == 3
def test_pop_front():
l = SingleLinkedList()
for i in range(5):
l.push_back(i)
for i in range(4):
assert l.pop_front() == i
assert l.head.data == i + 1
assert l.head.data == l.tail.data
assert l.tail.data == 4
l.pop_front()
assert l.head == None
assert l.tail == None
def information_getting(self):
info = input(
"If you want to know your statistics, insert info, otherwise GAME OVER: "
)
print()
if info.lower() == "info":
print()
print(f"* {self.ranking()} * {self.username}")
ll = SingleLinkedList()
for key, value in self.game["players"][self.username].items():
if type(value) != list:
ll.insert_last(f"{key}: {value}")
ll.print_list()
print()
print("Thanks for playing. See you next time!")
exit()
def sum_lists(list1, list2):
current_l1_node = list1.head()
current_l2_node = list2.head()
rest = 0
sum_list = SingleLinkedList.new()
while current_l1_node is not None or current_l2_node is not None:
l1_digit = current_l1_node.data() if current_l1_node else 0
l2_digit = current_l2_node.data() if current_l2_node else 0
sum = l1_digit + l2_digit + rest
if is_two_digit_number(sum):
rest = sum / 10
sum %= 10
else:
rest = 0
if at_both_ends(current_l1_node, current_l2_node):
sum_list.insert_data_at_beggining(sum)
if rest > 0:
sum_list.insert_data_at_beggining(rest)
break
else:
sum_list.insert_data_at_beggining(sum)
current_l1_node = current_l1_node.next_element() if current_l1_node else None
current_l2_node = current_l2_node.next_element() if current_l2_node else None
return sum_list
def __init__(self, iterable=None):
self._container = SingleLinkedList()
if iterable:
for item in iterable:
self.add(item)
fast = single_linked.head
slow = single_linked.head
# 慢指针前进过程中前半部分逆序
while fast and fast._next:
fast = fast._next._next
next_ = slow._next
slow._next = prev
prev = slow
slow = next_
# 针对奇数情况
if fast:
slow = slow._next
# 对比
while slow:
if slow.val != prev.val:
return False
else:
slow = slow._next
prev = prev._next
return True
if __name__ == "__main__":
test = SingleLinkedList()
for i in ['a', 'b']:
test.append(i)
print(is_palindrome2(test))
def test_iteration():
l = SingleLinkedList([0, 1, 2, 3, 4, 5])
i = 0
for element in l:
assert element == i
i += 1
def test_contains(self):
l = SingleLinkedList()
self.assertFalse(l.contains(0))
self.assertFalse(l.contains(1))
self.assertFalse(l.contains(None))
l = SingleLinkedList([1, 2, 3])
self.assertTrue(l.contains(1))
self.assertTrue(l.contains(2))
self.assertTrue(l.contains(2.0))
self.assertTrue(l.contains(3))
self.assertFalse(l.contains(4))
self.assertFalse(l.contains(-1))
self.assertFalse(l.contains(None))
self.assertFalse(l.contains({'some': 'datatype'}))
self.assertFalse(l.contains(2.01))
sum %= 10
else:
rest = 0
if at_both_ends(current_l1_node, current_l2_node):
sum_list.insert_data_at_beggining(sum)
if rest > 0:
sum_list.insert_data_at_beggining(rest)
break
else:
sum_list.insert_data_at_beggining(sum)
current_l1_node = current_l1_node.next_element() if current_l1_node else None
current_l2_node = current_l2_node.next_element() if current_l2_node else None
return sum_list
# TEST 1
list1 = SingleLinkedList.new()
list1.append_from_iterable(iterable=[1, 2, 3])
list2 = SingleLinkedList.new()
list2.append_from_iterable(iterable=[4, 1, 6])
new_list = sum_lists(list1, list2)
new_list.show()
# TEST 2
list1 = SingleLinkedList.new()
list1.append_from_iterable(iterable=[6, 4, 8])
list2 = SingleLinkedList.new()
list2.append_from_iterable(iterable=[3, 1, 9])
new_list = sum_lists(list1, list2)
new_list.show()
# TEST 3
def test_empty(self):
l = SingleLinkedList()
self.assertTrue(l.empty())
l = SingleLinkedList([0])
self.assertFalse(l.empty())
def __init__(self):
self._sll = SingleLinkedList()
def test_back():
l = SingleLinkedList()
for i in range(10):
l.push_back(i)
assert 9 == l.tail.data
def test_insert_before(self):
l = SingleLinkedList([1])
node = l.get_n_th_node(0)
l.insert_before(node, 5)
self._check_list(l, (5, 1))
l.insert_before(node, 4)
self._check_list(l, (5, 4, 1))
l.insert_before(l.get_n_th_node(0), 9)
self._check_list(l, (9, 5, 4, 1))
l.insert_before(l.get_n_th_node(2), 12)
self._check_list(l, (9, 5, 12, 4, 1))
def test_insert_at_position(self):
l = SingleLinkedList([9, 6, 5])
l.insert_at_position(0, -3)
self._check_list(l, (-3, 9, 6, 5))
l.insert_at_position(0, -4)
self._check_list(l, (-4, -3, 9, 6, 5))
l.insert_at_position(1, -5)
self._check_list(l, (-4, -5, -3, 9, 6, 5))
l.insert_at_position(4, -6)
self._check_list(l, (-4, -5, -3, 9, -6, 6, 5))
l.insert_at_position(7, -7)
self._check_list(l, (-4, -5, -3, 9, -6, 6, 5, -7))
def category_picking(self):
print(
f'''Hello {self.username}, lets play a game. To start, you need to pick a category.''',
end="\n\n")
ll = SingleLinkedList()
for i in self.game['categories'].keys():
ll.insert_last(i)
ll.print_list()
print()
self.category = input("Please pick a category: ")
print()
while True:
if ll.find(self.category) is None:
self.category = input(
"There is no such category. Please pick again: ")
print()
else:
word_ll = SingleLinkedList()
for i in self.list_of_categories[self.category]:
word_ll.insert_last(i)
self.word = word_ll.pick_random()
self.list_of_players[
self.username]["categories_picked"].append(
self.category.lower())
self.list_of_players[self.username]["favorite_category"] = max(
set(self.list_of_players[self.username]
["categories_picked"]),
key=self.list_of_players[
self.username]["categories_picked"].count)
break