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
