def build_huffman(OccuranceList): if OccuranceList == array_list.empty_list(): return None huffman_linked_list = linked_list.empty_list() for index, occurance in enumerate(OccuranceList.array): if occurance != 0: temp_leaf = Leaf( chr(index), occurance) #figure out how to go from into to asciib huffman_linked_list = linked_list.insert_sorted( huffman_linked_list, temp_leaf, comes_before) while linked_list.length(huffman_linked_list) != 1: temp_leaf_1 = linked_list.get(huffman_linked_list, 0) temp_leaf_2 = linked_list.get(huffman_linked_list, 1) huffman_linked_list = linked_list.remove_list(huffman_linked_list, 0) huffman_linked_list = linked_list.remove_list(huffman_linked_list, 0) total_freq = temp_leaf_1.freq + temp_leaf_2.freq if comes_before(temp_leaf_1, temp_leaf_2): if ord(temp_leaf_1.char) < ord(temp_leaf_2.char): temp_node = Node(temp_leaf_1.char, total_freq, temp_leaf_1, temp_leaf_2) else: temp_node = Node(temp_leaf_2.char, total_freq, temp_leaf_1, temp_leaf_2) huffman_linked_list = linked_list.insert_sorted( huffman_linked_list, temp_node, comes_before) return huffman_linked_list.first
def build_sorted_leaves(list): sorted = ll.empty_list() for i in range(0, 250): if list.values[i] != None: sorted = ll.insert_sorted(sorted, Leaf(i, list.values[i]), comes_before) return sorted
def convert_llist(alist): llist=None for i in range(array_list.length(alist)-1): g=array_list.get(alist, i) if(g != 0): llist=linked_list.insert_sorted(llist,Leaf(i,g),comes_before) return llist
def make_character_sorted_list(occurrence_list): sorted_list = linked_list.empty_list() for i in range(array_list.length(occurrence_list)): if occurrence_list[i] != None: leaf = make_leaf(chr(i), occurrence_list[i]) sorted_list = linked_list.insert_sorted(sorted_list, leaf, comes_before) return sorted_list
def build_leaf(x, func): #convert array into linked list new = linked_list.empty_list() for index in range(x.capacity): if (array_list.get(x, index)) != None: leaf_node = Leaf(chr(index), array_list.get(x, index)) new = linked_list.insert_sorted(new, leaf_node, func) return new
def build_Hufftree(alist): llist = convert_llist(alist) while (linked_list.length(llist) > 1): node1,llist=linked_list.remove(llist, 0) node2,llist=linked_list.remove(llist, 0) n=Node(0,(node1.freq+node2.freq),node1,node2) n.char=(node1.char<node2.char) and node1.char or node2.char llist=linked_list.insert_sorted(llist, n, comes_before) if(llist==None): return None else: return linked_list.get(llist, 0)
def join_leaves(sorted_list): #whilethere is more than one node in the list while linked_list.length(sorted_list) > 1: #remove two nodes from beginning of list (lowest frequencies) (leaf1, sorted_list) = linked_list.remove(sorted_list, 0) (leaf2, sorted_list) = linked_list.remove(sorted_list, 0) #create new Node with these two leaves as children, lesser of two on left(leaf1) node_frequency = leaf1.frequency + leaf2.frequency if leaf1.character < leaf2.character: character = leaf1.character else: character = leaf2.character new_node = Node(node_frequency, character, leaf1, leaf2) sorted_list = linked_list.insert_sorted(sorted_list, new_node, comes_before) return sorted_list
def build_tree(list): sorted = build_sorted_leaves(list) # TODO: re-nest build_sorted_leaves? while ll.length(sorted) > 1: # TODO: inefficient tup = ll.remove(sorted, 0) first = tup[0] sorted = tup[1] tup = ll.remove(sorted, 0) second = tup[0] sorted = tup[1] if first.char < second.char: char = first.char else: char = second.char node = Node(char, first.freq + second.freq, first, second) sorted = ll.insert_sorted(sorted, node, comes_before) return node
def build_tree(list, func): sorted_list1 = sorted_leaf_list(list) sorted_list = array_to_linked(sorted_list1) while linked_list.length(sorted_list) > 1: leaf_node, sorted_list = linked_list.remove(sorted_list, 0) leaf_node1, sorted_list = linked_list.remove(sorted_list, 0) if int(leaf_node.val) < int(leaf_node1.val): x = Node(leaf_node.val, leaf_node.freq + leaf_node1.freq, leaf_node, leaf_node1) else: x = Node(leaf_node1.val, leaf_node.freq + leaf_node1.freq, leaf_node, leaf_node1) sorted_list = linked_list.insert_sorted(sorted_list, x, func) ptree = linked_list.get(sorted_list, 0) return ptree
def build_nodes(leaves): if leaves.rest == None: return leaves.first while (leaves.rest != None): new = Node(leaves.first, leaves.rest.first) new.character = (leaves.first.character) + ( leaves.rest.first.character) sum = leaves.first.occurrence + leaves.rest.first.occurrence new.occurrence += sum if new.left.chrs < new.right.chrs: new.chrs = new.left.chrs else: new.chrs = new.right.chrs leaves = linked_list.insert_sorted(leaves, new, comes_before) if leaves.rest.rest != None: leaves = leaves.rest.rest return leaves.first