Huffman Decoding

using System;
using System.Collections.Generic;
using System.Linq;

namespace HuffmanEncoding
{
    // To store the frequency of character of the input data
    class FrequencyTable
    {
        private readonly Dictionary<char, int> _freq = new Dictionary<char, int>();

        public void Add(char c)
        {
            if (_freq.ContainsKey(c))
            {
                _freq[c]++;
            }
            else
            {
                _freq[c] = 1;
            }
        }

        public Dictionary<char, int> ToDictionary()
        {
            return _freq;
        }
    }

    // A Huffman tree node
    class HuffmanNode : IComparable<HuffmanNode>
    {
        public HuffmanNode Left { get; set; }
        public HuffmanNode Right { get; set; }
        public char Data { get; set; }
        public int Frequency { get; set; }

        public HuffmanNode(char data, int freq)
        {
            Data = data;
            Frequency = freq;
        }

        // Define the comparison method for sorting the nodes in the heap
        public int CompareTo(HuffmanNode other)
        {
            return Frequency - other.Frequency;
        }
    }

    // Utility class for creating Huffman codes
    class HuffmanEncoder
    {
        // To map each character its Huffman value
        private readonly Dictionary<char, string> _codes = new Dictionary<char, string>();

        // Create an empty min-heap
        private readonly List<HuffmanNode> _minHeap = new List<HuffmanNode>();

        // Function to build the Huffman tree and store it in minHeap
        private void BuildHuffmanTree(Dictionary<char, int> freq)
        {
            foreach (var kvp in freq)
            {
                _minHeap.Add(new HuffmanNode(kvp.Key, kvp.Value));
            }
            // Convert the list to a min-heap using the built-in sort method
            _minHeap.Sort();
            while (_minHeap.Count > 1)
            {
                var left = _minHeap.First();
                _minHeap.RemoveAt(0);
                var right = _minHeap.First();
                _minHeap.RemoveAt(0);
                var top = new HuffmanNode('$', left.Frequency + right.Frequency);
                top.Left = left;
                top.Right = right;
                _minHeap.Add(top);
                // Sort the list to maintain the min-heap property
                _minHeap.Sort();
            }
        }

        // Utility function to store characters along with their Huffman value in a hash table
        private void StoreCodes(HuffmanNode root, string str)
        {
            if (root == null)
            {
                return;
            }
            if (root.Data != '$')
            {
                _codes[root.Data] = str;
            }
            StoreCodes(root.Left, str + "0");
            StoreCodes(root.Right, str + "1");
        }

        // Utility function to print characters along with their Huffman value
        public void PrintCodes(HuffmanNode root, string str)
        {
            if (root == null)
            {
                return;
            }
            if (root.Data != '$')
            {
                Console.WriteLine(root.Data + " : " + str);
            }
            PrintCodes(root.Left, str + "0");
            PrintCodes(root.Right, str + "1");
        }

        // Function iterates through the encoded string s
        // If s[i] == '1' then move to node.right
        // If s[i] == '0' then move to node.left
        // If leaf node, append the node.data to our output string
        public string DecodeFile(HuffmanNode root, string s)
        {
           
            string ans = "";
            HuffmanNode curr = root;
            int n = s.Length;
            for (int i = 0; i < n; i++)
            {
                if (s[i] == '0')
                {
                    curr = curr.Left;
                }
                else
                {
                    curr = curr.Right;
                }

                // Reached leaf node
                if (curr.Left == null && curr.Right == null)
                {
                    ans += curr.Data;
                    curr = root;
                }
            }
            return ans + "\0";
        }

        // Function to build the Huffman tree and store it in minHeap
        public void BuildCodes(Dictionary<char, int> freq)
        {
            BuildHuffmanTree(freq);
            StoreCodes(_minHeap.First(), "");
        }

        public Dictionary<char, string> GetCodes()
        {
            return _codes;
        }

        public HuffmanNode GetRoot()
        {
            return _minHeap.First();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // Driver code
            string str = "geeksforgeeks";
            string encodedString = "";
            string decodedString;
            var freqTable = new FrequencyTable();
            foreach (char c in str)
            {
                freqTable.Add(c);
            }
            var huffmanEncoder = new HuffmanEncoder();
            huffmanEncoder.BuildCodes(freqTable.ToDictionary());
            Console.WriteLine("Character With their Frequencies:");
            foreach (var kvp in huffmanEncoder.GetCodes())
            {
                Console.WriteLine($"{kvp.Key} : {kvp.Value}");
            }

            foreach (char c in str)
            {
                encodedString += huffmanEncoder.GetCodes()[c];
            }

            Console.WriteLine("\nEncoded Huffman data:");
            Console.WriteLine(encodedString);

            // Function call
            decodedString = huffmanEncoder.DecodeFile(huffmanEncoder.GetRoot(), encodedString);
            Console.WriteLine("\nDecoded Huffman Data:");
            Console.WriteLine(decodedString);
        }
    }
}