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
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 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)