public char_freq(char_freq leftnode, char_freq rightnode, List <char_freq> frequency_list)
{
this.left_node_index = frequency_list.FindIndex(f => f == leftnode);
this.right_node_index = frequency_list.FindIndex(f => f == rightnode);
frequency_list[left_node_index].parent_node_index = frequency_list.FindIndex(f => f == this);
frequency_list[right_node_index].parent_node_index = frequency_list.FindIndex(f => f == this);
this.count = leftnode.Count + rightnode.Count;
}
/****This method will be called by compress_with_Huffman to create the huffman tree with the given character frequencies****/
private char_freq create_huffman_tree()
{
frequency_list = frequency_list.OrderBy(f => f.Count).ToList();//list the frequencies by frequency
char_freq root = new char_freq();
int index = 0;
int Num_entries = frequency_list.Count();
//keep on creating a parent node with the two lowest frequency entries that we haven't visited.
while (index + 1 < Num_entries)
{
char_freq newNode = new char_freq(frequency_list[index], frequency_list[index + 1], frequency_list);
frequency_list.Add(newNode);//add to correct place
root = newNode;
index += 2;
Num_entries = frequency_list.Count();
}
return(root);
}
/****This method will be called by compress_with_Huffman to create ****/
private void create_char_freq(string fileString)
{
foreach (char c in fileString)
{
bool found = false; //saves whether we've seen this character
foreach (char_freq entry in frequency_list) //look through the list - if char found, add 1 to count.
{
if (entry.ID == c)
{
found = true;
entry.Count++;
}
}
if (!found)//If not, create new entry with that char and count of 1
{
char_freq newEntry = new char_freq(c);
frequency_list.Add(newEntry);
}
}
}
private List <char_freq> compress(string coded_string, char last_char, List <char_freq> counted_char)
{
if (0 == coded_string.Length)
{
return(counted_char);
}
else
{
if (last_char == coded_string[0])
{
counted_char[counted_char.Count - 1].Count += 1;
}
else
{
char_freq newEntry = new char_freq(coded_string[0], 1);
counted_char.Add(newEntry);
}
return(compress(coded_string.Remove(0, 1), last_char, counted_char));
}
}
private void create_char_freq(string fileString)
{
foreach (char c in fileString)
{
bool found = false;
foreach (char_freq entry in frequency_list)
{
if (entry.ID == c)
{
found = true;
entry.Count++;
}
}
if (!found)
{
char_freq newEntry = new char_freq(c);
frequency_list.Add(newEntry);
}
}
}
private void Uncompress_with_Huffman(string InputFilename, string InputTreeFilename, string OutputFilename)
{
byte[] CompressedFileByte = File.ReadAllBytes(InputFilename);
string[] Huffman_tree = File.ReadAllLines(InputTreeFilename);
frequency_list = new List <char_freq>();
foreach (string Huffman_node in Huffman_tree)
{
string[] node_info = Huffman_node.Split(',');
char_freq newNode = new char_freq();//add correctly
frequency_list.Add(newNode);
}
int index = 0;
StringBuilder CompressedByteString = new StringBuilder();
foreach (byte b in CompressedFileByte)
{
CompressedByteString.Append(Convert.ToString(b, 2).PadLeft(8, '0'));
}
StringBuilder Uncompressed_fileString = new StringBuilder();
char_freq traversal =;//find root - make variable so that we know the type of node it is - add node, char node, or root node
while (index < CompressedByteString.Length)
{
if ((traversal.LeftNodeIndex ==) && (traversal.RightNodeIndex ==)) //if this is a edge node
{
Uncompressed_fileString.Append(traversal.ID);
}
if (CompressedByteString[index] == '1')
{
traversal = frequency_list[traversal.RightNodeIndex];
index++;
}
else
{
traversal = frequency_list[traversal.LeftNodeIndex];
index++;
}
}
}
private void compress(string fileString, char_freq root)
{
compressed_binary_string = new StringBuilder();
foreach (char c in fileString)
{
char_freq node = frequency_list.Find(f => f.ID == c);
string tempString = "";
while (node != root)
{
char_freq tempNode = frequency_list[node.ParentNodeIndex];
if (frequency_list[tempNode.LeftNodeIndex] == node)
{
tempString = '1' + tempString;
}
if (frequency_list[tempNode.RightNodeIndex] == node)
{
tempString = '0' + tempString;
}
node = tempNode;
}
compressed_binary_string.Append(tempString);
}
}
/****This method will be called by the form to compress the input file into huffman compressed output file****/
public void compress_with_Huffman(string InputFilename, string OutputFilename)
{
//we will first count the number of times each character appears in this file.
frequency_list = new List <char_freq>();
string fileString = File.ReadAllText(InputFilename);
create_char_freq(fileString);
char_freq root = create_huffman_tree(); //create a huffman tree based off of the frequency of each char in the file
compress(fileString, root); //convert the file into binary using the huffman tree
StringBuilder String_rep_tree = convert_tree(); //convert the tree into a savable format
//write the converted binary and huffman tree to appropriate file
int numBytes = compressed_binary_string.ToString().Length / 8;
compressed_fileByte = new byte[numBytes];
for (int i = 0; i < numBytes; ++i)
{
compressed_fileByte[i] = Convert.ToByte(compressed_binary_string.ToString().Substring(8 * i, 8), 2);
}
File.WriteAllBytes(OutputFilename, compressed_fileByte);
File.WriteAllText("HuffmanTreeData_" + OutputFilename, String_rep_tree.ToString());
}