def __parcours(L, i=0): res = "" if (L[i] == '1'): for j in range(8): res += L[i + j + 1] temp = chr(__todecimal(res)) return (bintree.BinTree(temp, None, None), i + 9) else: (a, x) = __parcours(L, i + 1) (c, x2) = __parcours(L, x) return (bintree.BinTree(None, a, c), x2)
def buildHuffmantree(inputList): """ Processes the frequency list into a Huffman tree according to the algorithm. """ H = heap.Heap() l = len(inputList) for i in inputList: H.push((i[0], bintree.BinTree(i[1], None, None))) while (l > 1): B = H.pop() B1 = H.pop() H.push((B[0] + B1[0], bintree.BinTree(None, B[1], B1[1]))) l = l - 1 return (H.pop()[1])
def __list2bst(L, left, right): if left == right: return None else: mid = left + (right - left) // 2 return bintree.BinTree(L[mid], __list2bst(L, left, mid), __list2bst(L, mid + 1, right))
def __2minlist(inputList): """ :param inputList: bintree list (result of __listtree(inputList)) :return: input list but with a new bintree created from the 2 smallest frequency of the list """ # first min mini1 = inputList[0] mini1freq = mini1.key[0] length = len(inputList) index = 0 for i in range(length): if inputList[i].key[0] < mini1freq: mini1 = inputList[i] mini1freq = mini1.key[0] index = i (inputList[index], inputList[length - 1]) = (inputList[length - 1], inputList[index]) mini1 = inputList.pop() # second min mini2 = inputList[0] mini2freq = mini2.key[0] index = 0 length = len(inputList) for i in range(length): if inputList[i].key[0] < mini2freq: mini2 = inputList[i] mini2freq = mini2.key[0] index = i (inputList[index], inputList[length - 1]) = (inputList[length - 1], inputList[index]) mini2 = inputList.pop() inputList.append( bintree.BinTree((mini1freq + mini2freq, None), mini1, mini2)) return inputList
def hier2tree(L, i = 1): if i >= len(L) or L[i] == None: return None else: C = bintree.BinTree(L[i], None, None) C.left = hier2tree(L, 2*i) C.right = hier2tree(L, 2*i+1) return C
def copy(B): if B == None: return None else: C = bintree.BinTree(B.key, None, None) C.left = copy(B.left) C.right = copy(B.right) return C
def __list2bst(L, left, right): if left == right: return None else: mid = left + (right - left) // 2 B = bintree.BinTree(L[mid], None, None) B.left = __list2bst(L, left, mid) B.right = __list2bst(L, mid + 1, right) return B
def leaf_insert(B, x): if B == None: return bintree.BinTree(x, None, None) else: if x <= B.key: B.left = leaf_insert(B.left, x) else: B.right = leaf_insert(B.right, x) return B
def __list2bst2(L, left, right): if left == right: return None else: mid = left + (right - left) // 2 while mid < right - 1 and L[mid] == L[mid + 1]: mid += 1 return bintree.BinTree(L[mid], __list2bst2(L, left, mid), __list2bst2(L, mid + 1, right))
def __buildTree(L, i=0): if i >= len(L) or L[i] == None: return (None, i+1) else: B = bintree.BinTree(L[i], None, None) i = i + 1 (B.left, i) = __buildTree(L, i) (B.right, i) = __buildTree(L, i) return (B, i)
def __listtree(inputList): """ :param inputList: list of Tuple(frequency, char) :return: a bintree list where each bintree is a leaf and have a Tuple(frequency, char) as key """ for i in range(len(inputList)): inputList[i] = bintree.BinTree((inputList[i][0], inputList[i][1]), None, None) return inputList
def insertBST(x, B): if B == None: return bintree.BinTree(x, None, None) else: if x != B.key: if x < B.key: B.left = insertBST(x, B.left) else: B.right = insertBST(x, B.right) return B
def __buildTreeS(L): if L == []: return None else: e = L.pop() if e == None: return None else: B = bintree.BinTree(e, None, None) B.left = __buildTreeS(L) B.right = __buildTreeS(L) return B
def __decodetree(charlist, structure): """ :param dataIN: the encoded data :param B: the new tree :param index: the index to go through the data :return: the tree """ if len(structure) <= 0: return None index_struct = len(structure) - 1 if structure[index_struct] == '1': structure.pop() index = len(charlist) - 1 key = charlist[index] charlist.pop() B = bintree.BinTree(key, None, None) return B elif structure[index_struct] == '0': structure.pop() B = bintree.BinTree(None, None, None) B.left = __decodetree(charlist, structure) B.right = __decodetree(charlist, structure) return B return None
def leaf_insert_iter(B, x): new = bintree.BinTree(x, None, None) P = None T = B while T != None: P = T if x <= T.key: T = T.left else: T = T.right if P == None: return new else: if x <= P.key: P.left = new else: P.right = new return B
def copy(B): if B == None: return None return bintree.BinTree(B.key, copy(B.left), copy(B.right))
def root_insertion(B, x): (L, R) = cut(B, x) return bintree.BinTree(x, L, R)