void HuffmanCompressor::deallocateTree(Node *node)
{
if (node != NULL) {
deallocateTree(node->left);
deallocateTree(node->right);
delete node;
}
}
void deallocateTree(struct node* p) {
if(p == NULL) {
return;
}
deallocateTree(p->left);
deallocateTree(p->right);
mf(p);
}
// Rekurzivno obidi stablo i obrisi ga
void deallocateTree(node ** tree) {
// Ako dodes do kraja vrati se razinu gore
if (*tree == NULL) {
return;
}
// Stablo je binarno, tako ga i obidi
deallocateTree(&((*tree)->left));
deallocateTree(&((*tree)->right));
// Izbrisi sve podatke
free((*tree)->val);
free(*tree);
}
void HuffmanCompressor::decompress(int size, const Bitset &transmitData, INT16 *dataOut)
{
transmitDataIndex = 0;
this->transmitData = transmitData;
// Reconstruct Huffman tree
Node *huffmanTree = NULL;
reconstructHuffmanTree(huffmanTree);
++transmitDataIndex; // dispose last bit
// Decode data values
UINT i = 0; // temp
Node *head = huffmanTree;
Node *current = head;
bool pseudoEOF = false;
while (!pseudoEOF) {
//timer.startTimer();
INT16 value = (transmitData[transmitDataIndex] == 0) ? current->left->value : current->right->value;
if (value == INT16_MAX) {
pseudoEOF = true;
} else if (value != INT16_MIN) {
dataOut[i++] = value;
current = head;
} else {
current = (transmitData[transmitDataIndex] == 0) ? current->left : current->right;
}
++transmitDataIndex;
}
// Deallocate memory
deallocateTree(huffmanTree);
}
void bk::Bktree::deallocateTree(Node* root) {
if(root->getChildren().size() == 0) {
delete root;
return;
}
for(int i = 0; i < root->getChildren().size(); i++) {
deallocateTree(root->getChildrenNodePosition(i));
}
}
int main() {
int n = 0;
root = loadPRE(&n);
printPRE(root);
printf("\n");
deallocateTree(root);
return 0;
}
void HuffmanCompressor::compress(int size, const INT16 *data, Bitset &transmitData)
{
// Find frequency of each value
for (UINT i = 0; i < size; ++i)
++dataFrequency[data[i]];
dataFrequency[INT16_MAX] = 1; // use max value as the pseudo EOF
// Store each frequency as a (leaf) node in minimum heap
for (auto it = dataFrequency.begin(); it != dataFrequency.end(); ++it) {
Node *node = new Node(it->first, it->second);
minHeap.push(node);
}
// Generate Huffman tree
while (minHeap.size() != 1) {
Node *right = minHeap.top();
minHeap.pop();
Node *left = minHeap.top();
minHeap.pop();
minHeap.push(new Node(left->frequency + right->frequency, left, right)); // Create internal node
}
Node *huffmanTree = minHeap.top();
// Get Huffman codes for each value and generate encoded Huffman tree
std::string code("");
std::string encodedHuffmanTree("");
getHuffmanCode(huffmanTree, code, encodedHuffmanTree);
std::reverse(encodedHuffmanTree.begin(), encodedHuffmanTree.end()); // TODO: try encodedHuffmanTree = bit + encodedHuffmanTree to see if performance is better
// Encode data values
std::string encodedData("");
for (UINT i = 0; i < size; ++i) {
encodedData += huffmanCodes[data[i]];
}
encodedData += huffmanCodes[INT16_MAX]; // add pseudo EOF
std::reverse(encodedData.begin(), encodedData.end());
// Convert data to bit array
transmitData = Bitset(encodedData + encodedHuffmanTree);
// Deallocate memory
deallocateTree(huffmanTree);
minHeap.pop();
dataFrequency.clear();
huffmanCodes.clear();
}
bk::Bktree::~Bktree() {
deallocateTree(root);
}
