// This method is to encode text based on the this tree
public byte[] Encode(string text)
{
// a local recursive function to convert a character into an array of bits based on the root huffman node
BitArray convertToBitarray(HuffmanNode n, char c)
{
// if we found a leaf, return the code
if (n.IsLeaf)
{
return(n.Code);
}
else
{
// Call this function again, but with either the left or the right
if (n.LeftChildNode.Symbol.Contains(c))
{
return(convertToBitarray(n.LeftChildNode, c));
}
else if (n.RightChildNode.Symbol.Contains(c))
{
return(convertToBitarray(n.RightChildNode, c));
}
else
{
throw new Exception("something went wrong when converting the tree");
}
}
}
// Init list for the bits
BitList bits = new BitList();
// make the text into a character array, and loop tought it
text.ToCharArray().ToList().ForEach(x => {
// Use the recursive function from before to calculate the bits
// Add the bits to the list of bits
bits.AddBitArray(convertToBitarray(Root, x));
});
// We add a 1 to the list
bits.Add(true);
// We fill the list up with 0's, until it is divisible by 8
while (bits.Count % 8 != 0)
{
bits.Add(false);
}
// Create the array of bytes
byte[] bytes = new byte[bits.Count / 8];
// Copy the array of bits to the array of bytes
bits.ToBitArray().CopyTo(bytes, 0);
// Return the bytes
return(bytes);
}
// This method is to encode text based on the this tree
// Denne funktion enkoder tekst baseret på det foregående træ
public byte[] Encode(string text)
{
// a local recursive function to convert a character into an array of bits based on the root huffman node
// En lokal rekursiv funktion for at konvertere et symbol om til et array af bits baseret på Hoffman nodens rod
BitArray convertToBitarray(HuffmanNode n, char c)
{
// if we found a leaf, return the code
// Hvis det er et blad, returnerer koden
if (n.IsLeaf)
{
return(n.Code);
}
else
{
// Call this function again, but with either the left or the right
// Kald denne funktion igen, men med enten højre eller venstre
if (n.LeftChildNode.Symbol.Contains(c))
{
return(convertToBitarray(n.LeftChildNode, c));
}
else if (n.RightChildNode.Symbol.Contains(c))
{
return(convertToBitarray(n.RightChildNode, c));
}
else
{
throw new Exception("something went wrong when converting the tree");
}
}
}
// Init list for the bits
// Ny liste for bitsene
BitList bits = new BitList();
// make the text into a character array, and loop trough it
// Lav teksten om til et symbol-array, og loop igennem det
text.ToCharArray().ToList().ForEach(x => {
// Use the recursive function from before to calculate the bits
// Add the bits to the list of bits
// Der bruges den rekursive funktion fra før til at udregne bitsene
// Tilføj bitsene til listen over bits
bits.AddBitArray(convertToBitarray(Root, x));
});
// We add a 1 to the list
// Der tilføjes et 1 til listen
bits.Add(true);
// We fill the list up with 0's, until it is divisible by 8
// Listen fyldes op med 0'er, indtil at den kan divideres med 8
while (bits.Count % 8 != 0)
{
bits.Add(false);
}
// Create the array of bytes
// Der laves et array over bytes
byte[] bytes = new byte[bits.Count / 8];
// Copy the array of bits to the array of bytes
// array over bits indsættes ind i array over bytes
bits.ToBitArray().CopyTo(bytes, 0);
// Return the bytes
// Returner bytes
return(bytes);
}