def test_heapify(self):
pq = MinPQ([9, 6, 5, 2, 3])
self.assertEqual(pq.arr, [2, 3, 5, 6, 9])
pq = MinPQ([6, 3, 7, 2, 8, 1])
self.assertEqual(pq.arr, [1, 2, 6, 3, 8, 7])
pq = MinPQ([1, 3, 6, 8])
self.assertEqual(pq.arr, [1, 3, 6, 8])
def test_repr(self):
""" Tests the repr function"""
pq_test = MinPQ()
pq_test.insert(3)
pq_test.insert(4)
expected = '[3, 4]'
self.assertEqual(expected, repr(pq_test))
def __init__(self, G):
self._mst = []
self._pq = MinPQ(G.V())
self._marked = [False] * G.V()
self._weight = 0
for v in range(0, G.V()):
if not self._marked[v]:
self._prim(G, v)
def test_pq2(self):
pq = MinPQ()
pq2 = MinPQ()
self.assertEqual(pq2 == pq, True)
pq.insert(0)
pq.insert(0)
pq.insert(1)
self.assertEqual(pq.min(), 0)
self.assertEqual(pq.del_min(), 0)
self.assertEqual(pq.del_min(), 0)
self.assertEqual(pq.del_min(), 1)
def test_pq1(self):
pq = MinPQ()
self.assertTrue(pq.is_empty())
for i in reversed(range(5)):
print("pq.insert(", i, ")")
pq.insert(i)
self.assertEqual(pq.size(), 5)
self.assertFalse(pq.is_empty())
self.assertEqual(pq.min(), 0)
def test_use_case_two(self):
""" Implementation of use case 2 as outlined in lab instructions"""
pq_test = MinPQ([5, 4, 3, 2, 1])
self.assertEqual(5, pq_test.size())
self.assertEqual(5, pq_test.capacity)
self.assertEqual(pq_test.num_items, pq_test.capacity)
self.assertTrue(pq_test.arr == [1, 2, 3, 5, 4])
self.assertEqual(1, pq_test.min())
self.assertEqual(1, pq_test.del_min())
self.assertEqual(2, pq_test.del_min())
self.assertFalse(pq_test.is_empty())
self.assertEqual(3, pq_test.del_min())
self.assertEqual(4, pq_test.del_min())
self.assertEqual(5, pq_test.del_min())
self.assertEqual(2, pq_test.capacity)
self.assertEqual(0, pq_test.size())
self.assertTrue(pq_test.is_empty())
def __init__(self, G):
self.pq = MinPQ() # 横切边（包括失效的边）
self.marked = [False] * G.V() # 最小生成树的顶点
self.mst = [] # 最小生成树的边
self.visit(G, 0) # 假设G是联通的
while not self.pq.isEmpty():
# 遍历横切边
e = self.pq.delMin() # 取最小的边
v = e.either()
w = e.other(v)
if self.marked[v] and self.marked[w]:
# 如果边的两个顶点都已经在树里就跳过这个边
continue
self.mst.append(e) # 将边加入最小生成树
if not self.marked[v]:
self.visit(G, v)
if not self.marked[w]:
self.visit(G, w)
def test_2(self):
pq = MinPQ([5, 4, 3, 2, 1])
self.assertEqual(pq.size(), 5)
self.assertTrue(pq.capacity == 5)
self.assertTrue(pq.capacity == pq.num_items)
self.assertTrue(pq.arr == [1, 2, 3, 5, 4])
self.assertEqual(pq.min(), 1)
self.assertEqual(pq.del_min(), 1)
self.assertEqual(pq.del_min(), 2)
self.assertEqual(pq.del_min(), 3)
self.assertEqual(pq.del_min(), 4)
self.assertEqual(pq.del_min(), 5)
self.assertTrue(pq.capacity == 2)
self.assertEqual(pq.size(), 0)
self.assertTrue(pq.is_empty())
def test_pq4(self):
arr = [5, 2, 3, 4, 1]
print(arr)
pq = MinPQ(arr)
print("pq.heapify(",arr,")")
self.assertEqual(pq.size(), 5)
self.assertEqual(pq.capacity, 5)
self.assertFalse(pq.is_empty())
self.assertEqual(pq.min(), 1)
self.assertEqual(pq.del_min(), 1)
self.assertEqual(pq.del_min(), 2)
self.assertEqual(pq.del_min(), 3)
self.assertEqual(pq.del_min(), 4)
self.assertEqual(pq.del_min(), 5)
self.assertTrue(pq.is_empty())
class LazyPrimMST:
# Compute a minimum spanning tree (or forest) of an edge-weighted graph.
#the edge-weighted graph
def __init__(self, G):
self._mst = []
self._pq = MinPQ(G.V())
self._marked = [False] * G.V()
self._weight = 0
for v in range(0, G.V()):
if not self._marked[v]:
self._prim(G, v)
# run Prim's algorithm
def _prim(self, G, s):
self._scan(G, s)
while not self._pq.isEmpty():
e = self._pq.del_min()
v = e.either()
w = e.other(v)
assert (self._marked[v] or self._marked[w])
if (self._marked[v] and self._marked[w]):
continue
self._mst.append(e)
self._weight += e.weight()
if not self._marked[v]:
self._scan(G, v)
if not self._marked[w]:
self._scan(G, w)
# add all edges e incident to v onto pq if the other endpoint has not yet been scanned
def _scan(self, G, v):
assert not self._marked[v]
self._marked[v] = True
for e in G.adj(v):
if not self._marked[e.other(v)]:
self._pq.insert(e)
def weight(self):
return self._weight
def edges(self):
return self._mst
def create_huff_tree(list_of_freqs):
"""creates the root node of a Huffman Tree using a list of freqencies
Args:
list_of_freqs (list): list of size 256 integers with the frequencies of characters in file
Returns:
HuffmanNode: the root of Huffman Tree
"""
heap_arr = []
for i in range(len(list_of_freqs)):
if list_of_freqs[i] != 0:
heap_arr.append(HuffmanNode(list_of_freqs[i], chr(i)))
min_heap = MinPQ(heap_arr)
while min_heap.num_items > 1:
huff_node1 = min_heap.del_min()
huff_node2 = min_heap.del_min()
new_huff_node = HuffmanNode(huff_node1.freq + huff_node2.freq,
min(huff_node1.char, huff_node2.char))
new_huff_node.left, new_huff_node.right = huff_node1, huff_node2
min_heap.insert(new_huff_node)
return min_heap.arr[0]
def test_pq(self):
pq = MinPQ([3, 10, 231, 5])
self.assertEqual(pq.is_empty(), False)
self.assertEqual(pq.size(), 4)
self.assertEqual(pq.capacity, 4)
self.assertEqual(pq.min(), 3)
self.assertEqual(pq.del_min(), 3)
self.assertEqual(pq.del_min(), 5)
self.assertEqual(pq.del_min(), 10)
self.assertEqual(pq.del_min(), 231)
self.assertRaises(IndexError, pq.min)
self.assertRaises(IndexError, pq.del_min)
self.assertEqual(pq.is_empty(), True)
self.assertEqual(pq.num_items, 0)
class LazyPrimMST(MST):
"""最小生成树的Prim算法的延时实现"""
def __init__(self, G):
self.pq = MinPQ() # 横切边（包括失效的边）
self.marked = [False] * G.V() # 最小生成树的顶点
self.mst = [] # 最小生成树的边
self.visit(G, 0) # 假设G是联通的
while not self.pq.isEmpty():
# 遍历横切边
e = self.pq.delMin() # 取最小的边
v = e.either()
w = e.other(v)
if self.marked[v] and self.marked[w]:
# 如果边的两个顶点都已经在树里就跳过这个边
continue
self.mst.append(e) # 将边加入最小生成树
if not self.marked[v]:
self.visit(G, v)
if not self.marked[w]:
self.visit(G, w)
def visit(self, G, v):
"""
将顶点加入最小生成树
"""
self.marked[v] = True
for e in G.adj(v):
# 将另一个顶点不在最小生成树中的邻接边加入横切边中
if not self.marked[e.other(v)]:
self.pq.insert(e)
def edges(self):
return self.mst
def weight(self):
weights = 0
for e in self.mst:
weights += e.weight()
return weights
class LazyPrimMST(MST):
"""最小生成树的Prim算法的延时实现"""
def __init__(self, G):
self.pq = MinPQ() # 横切边（包括失效的边）
self.marked = [False] * G.V() # 最小生成树的顶点
self.mst = [] # 最小生成树的边
self.visit(G, 0) # 假设G是联通的
while not self.pq.isEmpty():
# 遍历横切边
e = self.pq.delMin() # 取最小的边
v = e.either()
w = e.other(v)
if self.marked[v] and self.marked[w]:
# 如果边的两个顶点都已经在树里就跳过这个边
continue
self.mst.append(e) # 将边加入最小生成树
if not self.marked[v]:
self.visit(G, v)
if not self.marked[w]:
self.visit(G, w)
def visit(self, G, v):
"""
将顶点加入最小生成树
"""
self.marked[v] = True
for e in G.adj(v):
# 将另一个顶点不在最小生成树中的邻接边加入横切边中
if not self.marked[e.other(v)]:
self.pq.insert(e)
def edges(self):
return self.mst
def weight(self):
weights = 0
for e in self.mst:
weights += e.weight()
return weights
def _solve(cls, board):
queue = MinPQ()
queue_twin = MinPQ()
twin = board.twin
while not board.is_goal():
# get the neighbours
neighbours = board.neighbours
# insert neighbours in the min pq
for neighbour in neighbours:
queue.insert(neighbour)
# pop min (= lowest manhattan score) board from the min pq
board = queue.del_min()
# run through the same steps for twin board and check if it's solved
twin_neighbours = twin.neighbours
for neighbour in twin_neighbours:
queue_twin.insert(neighbour)
twin = queue_twin.del_min()
if twin.is_goal():
# twin is solved, which means that our actual board is unsolvable
return None
# return the final board
return board
def create_huff_tree(list_of_freqs):
"""builds a huffman tree
Args:
list_of_freqs(list): list of frequencies from cnt_freq
Returns:
HuffmanNode: root node of the huffman tree
"""
min_huff = MinPQ() # min pq of huffman nodes
# for i in range(len(list_of_freqs)): # method 2: insert all huffman nodes
for i, item in enumerate(list_of_freqs):
if list_of_freqs[i] != 0:
min_huff.insert(HuffmanNode(list_of_freqs[i], chr(i)))
while min_huff.num_items != 1: # until a root node
low = min_huff.del_min() # HuffmanNode
low_2 = min_huff.del_min() # HuffmanNode
if ord(low.char) < ord(low_2.char):
char = low.char
else:
char = low_2.char
new_huff = HuffmanNode(low.freq + low_2.freq, char, low, low_2)
min_huff.insert(new_huff)
return min_huff.del_min() # pop out root node
def create_huff_tree(list_of_freqs):
"""returns the root node of a Huffman Tree
"""
huff_tree = []
for idx in range(len(list_of_freqs)):
if list_of_freqs[idx] != 0:
huff_tree.append(HuffmanNode(list_of_freqs[idx], chr(idx)))
huff_arr = MinPQ()
huff_arr.heapify(huff_tree)
while huff_arr.num_items > 1:
node1 = huff_arr.del_min()
node2 = huff_arr.del_min()
freq = node1.freq + node2.freq
char = min(node1.char, node2.char)
new_huff_node = HuffmanNode(freq, char)
new_huff_node.left = node1
new_huff_node.right = node2
huff_arr.insert(new_huff_node)
return huff_arr.min()
def create_huff_tree(list_of_freqs):
"""Creates a huffman tree given a list of character frequencies.
Arguments:
list_of_freqs (list): List of character frequencies from cnt_freq()
Returns:
The root node of the huffman tree created from the list of frequencies
"""
pq_arr = []
for char, freq in enumerate(list_of_freqs):
if freq > 0:
pq_arr.append(HuffmanNode(chr(char), freq, None, None))
min_pq = MinPQ(pq_arr)
while min_pq.size() > 1:
left = min_pq.del_min()
right = min_pq.del_min()
min_char = min(left.char, right.char)
parent_node = HuffmanNode(min_char, left.freq + right.freq, left, right)
min_pq.insert(parent_node)
return min_pq.min()
def __init__(self, G):
self.pq = MinPQ() # 横切边（包括失效的边）
self.marked = [False] * G.V() # 最小生成树的顶点
self.mst = [] # 最小生成树的边
self.visit(G, 0) # 假设G是联通的
while not self.pq.isEmpty():
# 遍历横切边
e = self.pq.delMin() # 取最小的边
v = e.either()
w = e.other(v)
if self.marked[v] and self.marked[w]:
# 如果边的两个顶点都已经在树里就跳过这个边
continue
self.mst.append(e) # 将边加入最小生成树
if not self.marked[v]:
self.visit(G, v)
if not self.marked[w]:
self.visit(G, w)
def create_huff_tree(list_of_freqs):
""" Create a Huffman Tree from list of character frequencies
Args:
list_of_freqs(list): list with length of 256 characters
Returns:
MinPQ: the root node of the Min Priority Queue constructed from
the Huffman Nodes
"""
priority_queue_list = []
for each in range(len(list_of_freqs)):
if list_of_freqs[each] > 0:
char = chr(each)
freq = list_of_freqs[each]
node = HuffmanNode(freq, char)
priority_queue_list.append(node)
priority_queue = MinPQ(priority_queue_list)
if priority_queue.size() == 0:
return None
while priority_queue.size() > 1:
# Retrieves the two smallest occurring Nodes from the queue
node_1 = priority_queue.del_min()
node_2 = priority_queue.del_min()
# Determine the representation of the min chr representation
min_chr = min(node_1.char, node_2.char)
# Sum the different frequencies, create new Node, and add to queue
sum_freq = node_1.freq + node_2.freq
new_node = HuffmanNode(sum_freq, min_chr, node_1, node_2)
priority_queue.insert(new_node)
return priority_queue.del_min()
def setUp(self):
self.pq1 = MinPQ()
self.pq2 = MinPQ()
def test_min_pq(self):
minq = MinPQ([5, 4, 3, 2, 1, 0])
minq2 = MinPQ()
minq2.insert(0)
minq2.insert(1)
self.assertEqual(minq2.capacity, 2)
minq2.insert(2)
self.assertEqual(minq2.capacity, 4)
minq2.insert(3)
minq2.insert(4)
minq2.insert(5)
self.assertEqual(minq2.min(), 0)
minq2.del_min()
self.assertEqual(minq2.min(), 1)
self.assertEqual(minq2.size(), 5)
minq2.del_min()
minq2.del_min()
self.assertEqual(minq2.capacity, 8)
minq2.del_min()
self.assertEqual(minq2.capacity, 4)
minq2.del_min()
minq2.del_min()
self.assertRaises(IndexError, minq2.del_min)
def test_1(self):
pq = MinPQ()
pq.insert(5)
pq.insert(3)
self.assertEqual(pq.capacity, 2)
pq.insert(6)
self.assertEqual(pq.size(), 3)
self.assertTrue(pq.capacity == 4)
self.assertEqual(pq.min(), 3)
self.assertEqual(pq.del_min(), 3)
self.assertEqual(pq.del_min(), 5)
self.assertEqual(pq.del_min(), 6)
self.assertEqual(pq.size(), 0)
self.assertTrue(pq.is_empty())
self.assertTrue(pq.capacity == 2)
def create_huff_tree(list_of_freqs):
"""returns the root node of a Huffman Tree
"""
tree = MinPQ()
def test_full_functionality(self):
""" Tests the bulk functionality of the MinPQ class"""
pq_test = MinPQ()
pq_test.insert(6)
self.assertEqual(2, pq_test.capacity)
self.assertEqual(pq_test.size(), pq_test.num_items)
pq_test.insert(7)
self.assertEqual([6, 7], pq_test.arr)
pq_test.insert(2)
self.assertEqual(3, pq_test.size())
self.assertEqual([2, 7, 6, None], pq_test.arr)
self.assertFalse(pq_test.is_empty())
self.assertEqual(2, pq_test.del_min())
self.assertEqual(6, pq_test.del_min())
self.assertEqual(7, pq_test.del_min())
self.assertTrue(pq_test.is_empty())
def test_pq3(self):
pq = MinPQ()
self.assertTrue(pq.is_empty())
i = 1
print("pq.insert(", i, ")")
pq.insert(i)
self.assertEqual(pq.min(), 1)
i = 5
print("pq.insert(", i, ")")
pq.insert(i)
self.assertEqual(pq.min(), 1)
i = 3
print("pq.insert(", i, ")")
pq.insert(i)
self.assertEqual(pq.del_min(), 1)
i = 4
print("pq.insert(", i, ")")
pq.insert(i)
self.assertEqual(pq.min(), 3)
i = 2
print("pq.insert(", i, ")")
pq.insert(i)
self.assertEqual(pq.min(), 2)
self.assertEqual(pq.del_min(), 2)
list_of_freqs[ord(char)] += 1
return list_of_freqs
def create_huff_tree(list_of_freqs):
"""returns the root node of a Huffman Tree
"""
tree = MinPQ()
<<<<<<< HEAD
for i in range(len(list_of_freqs)):
if list_of_freqs[i] != 0:
new = HuffmanNode(list_of_freqs[i], chr(i))
# tree.insert(new)
hufflist.append(new)
hufflist.sort()
# print(hufflist)
tree = MinPQ(hufflist)
# print('TREE AFTER INSERTION:\n', tree)
=======
for idx, freq in enumerate(list_of_freqs):
if freq != 0:
new = HuffmanNode(freq, chr(idx))
tree.insert(new)
>>>>>>> 1c1c70a6eb7b91e2d3714eb49057c9513665ab0d
while tree.num_items > 1:
left = tree.del_min()
right = tree.del_min()
freq_sum = left.freq + right.freq
parent = HuffmanNode(freq_sum, min(left.char, right.char))
parent.left = left
parent.right = right
tree.insert(parent)
class MinPQTests(unittest.TestCase):
def setUp(self):
self.pq1 = MinPQ()
self.pq2 = MinPQ()
def test_eq_repr(self):
self.assertEqual(repr(self.pq1), 'MinPQ([None, None])')
self.assertEqual(self.pq1, self.pq2)
self.assertEqual(self.pq1.size(), 0)
self.assertEqual(self.pq2.size(), 0)
self.pq1.insert(0)
self.pq1.insert(4)
self.pq1.insert(3)
self.pq2.insert(4)
self.pq2.insert(3)
self.pq2.insert(0)
self.assertEqual(repr(self.pq1), 'MinPQ([0, 4, 3, None])')
self.assertEqual(self.pq1.size(), 3)
self.assertEqual(self.pq1.min(), 0)
self.assertEqual(self.pq1, self.pq2)
def test_heapify(self):
pq = MinPQ([9, 6, 5, 2, 3])
self.assertEqual(pq.arr, [2, 3, 5, 6, 9])
pq = MinPQ([6, 3, 7, 2, 8, 1])
self.assertEqual(pq.arr, [1, 2, 6, 3, 8, 7])
pq = MinPQ([1, 3, 6, 8])
self.assertEqual(pq.arr, [1, 3, 6, 8])
def test_insert_del_size(self):
self.assertRaises(IndexError, self.pq1.del_min)
self.pq1.insert(1)
self.assertEqual(self.pq1.size(), 1)
self.assertEqual(self.pq1.arr, [1, None])
self.pq1.insert(6)
self.assertEqual(self.pq1.size(), 2)
self.assertEqual(self.pq1.arr, [1, 6])
self.pq1.insert(5)
self.assertEqual(self.pq1.size(), 3)
self.assertEqual(self.pq1.arr, [1, 6, 5, None])
self.assertEqual(self.pq1.del_min(), 1)
self.assertEqual(self.pq1.arr, [5, 6, None, None])
self.pq1.insert(1)
self.assertEqual(self.pq1.arr, [1, 6, 5, None])
def test_1(self):
pq = MinPQ()
pq.insert(5)
pq.insert(3)
self.assertEqual(pq.capacity, 2)
pq.insert(6)
self.assertEqual(pq.size(), 3)
self.assertTrue(pq.capacity == 4)
self.assertEqual(pq.min(), 3)
self.assertEqual(pq.del_min(), 3)
self.assertEqual(pq.del_min(), 5)
self.assertEqual(pq.del_min(), 6)
self.assertEqual(pq.size(), 0)
self.assertTrue(pq.is_empty())
self.assertTrue(pq.capacity == 2)
def test_2(self):
pq = MinPQ([5, 4, 3, 2, 1])
self.assertEqual(pq.size(), 5)
self.assertTrue(pq.capacity == 5)
self.assertTrue(pq.capacity == pq.num_items)
self.assertTrue(pq.arr == [1, 2, 3, 5, 4])
self.assertEqual(pq.min(), 1)
self.assertEqual(pq.del_min(), 1)
self.assertEqual(pq.del_min(), 2)
self.assertEqual(pq.del_min(), 3)
self.assertEqual(pq.del_min(), 4)
self.assertEqual(pq.del_min(), 5)
self.assertTrue(pq.capacity == 2)
self.assertEqual(pq.size(), 0)
self.assertTrue(pq.is_empty())
def test_use_case_one(self):
""" Implementation of use case 1 as outlined in lab instructions"""
pq_test = MinPQ()
pq_test.insert(5)
pq_test.insert(3)
self.assertTrue(pq_test.capacity == 2)
pq_test.insert(6)
self.assertEqual(3, pq_test.size())
self.assertEqual(3, pq_test.min())
self.assertEqual(3, pq_test.del_min())
self.assertEqual(5, pq_test.del_min())
self.assertEqual(6, pq_test.del_min())
self.assertEqual(0, pq_test.size())
self.assertTrue(pq_test.is_empty())
self.assertEqual(2, pq_test.capacity)
