public HuffmanTree(HuffmanLeafNode <T> firstInit, HuffmanLeafNode <T> secondInit)
{
root = new HuffmanTreeNode();
if (firstInit.frequency > secondInit.frequency)
{
root.left = secondInit;
root.right = firstInit;
}
else
{
root.left = firstInit;
root.right = secondInit;
}
CalcRootFrequency();
}
public static HuffmanTree <T> ReconstructFromTable(Dictionary <HFCode, T> table)
{
HuffmanTree <T> hfTree = new HuffmanTree <T>();
hfTree.root = new HuffmanTreeNode(-1);
foreach (KeyValuePair <HFCode, T> pair in table)
{
BitArray bitCode = pair.Key.GetBitCode();
HuffmanTreeNode curNode = hfTree.root;
HuffmanTreeNode prevNode = curNode;
for (int i = 0; i < bitCode.Length; ++i)
{
//Go left or right depending on bitCode
prevNode = curNode;
curNode = (bitCode[i]) ? curNode.right : curNode.left;
if (curNode == null)
{
if (i == bitCode.Length - 1) //Create leaf
{
HuffmanLeafNode <T> hfLeafNode = new HuffmanLeafNode <T>(pair.Value, 0);
curNode = hfLeafNode;
}
else
{
curNode = new HuffmanTreeNode(i);
}
if (bitCode[i])
{
prevNode.right = curNode;
}
else
{
prevNode.left = curNode;
}
}
}
}
return(hfTree);
}
private HuffmanTree <T> GenerateTree(HuffmanList <T> list)
{
IHuffmanNode[] curNodes = new IHuffmanNode[4];
HuffmanListNode <T> listFirst, listSecond;
HuffmanListNode <HuffmanTree <T> > treeFirst, treeSecond;
HuffmanList <HuffmanTree <T> > subTrees = new HuffmanList <HuffmanTree <T> >();
while (list.Count > 0 || subTrees.Count > 1)
{
list.GetTwoLowestFreqNodes(out listFirst, out listSecond);
subTrees.GetTwoLowestFreqNodes(out treeFirst, out treeSecond);
curNodes[0] = listFirst;
curNodes[1] = listSecond;
if (treeFirst != null)
{
curNodes[2] = treeFirst.info.root;
if (treeSecond != null)
{
curNodes[3] = treeSecond.info.root;
}
else
{
curNodes[3] = null;
}
}
else
{
curNodes[2] = curNodes[3] = null;
}
double lowestFreq = double.MaxValue, secondLowestFreq = double.MaxValue;
int lowestIndex = 0, secondLowestIndex = 1;
for (int i = 0; i < 4; ++i)
{
if (curNodes[i] != null)
{
if (curNodes[i].GetFrequency() <= lowestFreq)
{
secondLowestFreq = lowestFreq;
secondLowestIndex = lowestIndex;
lowestFreq = curNodes[i].GetFrequency();
lowestIndex = i;
}
else if (curNodes[i].GetFrequency() <= secondLowestFreq)
{
secondLowestFreq = curNodes[i].GetFrequency();
secondLowestIndex = i;
}
}
}
//If both nodes are from list, create a new subtree
if (lowestIndex < 2 && secondLowestIndex < 2)
{
HuffmanLeafNode <T> first = new HuffmanLeafNode <T>(listFirst.info, listFirst.frequency);
HuffmanLeafNode <T> second = new HuffmanLeafNode <T>(listSecond.info, listSecond.frequency);
HuffmanTree <T> newSubTree = new HuffmanTree <T>(first, second);
subTrees.Add(newSubTree, newSubTree.GetRootFrequency());
list.RemoveNode(listFirst);
list.RemoveNode(listSecond);
}
else if (lowestIndex >= 2 && secondLowestIndex >= 2) //Merge trees
{
treeFirst.info.Combine(treeSecond.info.root);
subTrees.SetFrequency(treeFirst, treeFirst.info.GetRootFrequency());
subTrees.RemoveNode(treeSecond);
}
else
{
HuffmanLeafNode <T> first = new HuffmanLeafNode <T>(listFirst.info, listFirst.frequency);
treeFirst.info.Combine(first);
subTrees.SetFrequency(treeFirst, treeFirst.info.GetRootFrequency());
list.RemoveNode(listFirst);
}
}
return(subTrees[0].info);
}
