Add Huffman in C#.

chapters/data_compression/huffman/code/cs/HuffmanCoding.cs

@@ -0,0 +1,181 @@
+// submitted by Julian Schacher (jspp) with help by gustorn.
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace HuffmanCoding
+{
+    public class EncodingResult 
+    {
+        public List<bool> BitString { get; set; }
+        public Dictionary<char, List<bool>> Dictionary { get; set; }
+        public HuffmanCoding.Node Tree { get; set; }
+
+        public EncodingResult(List<bool> bitString, Dictionary<char, List<bool>> dictionary, HuffmanCoding.Node tree)
+        {
+            this.BitString = bitString;
+            this.Dictionary = dictionary;
+            this.Tree = tree;
+        }
+    }
+
+    public static class HuffmanCoding
+    {
+        // The Node class used for the Huffman Tree.
+        public class Node : IComparable<Node>
+        {
+            public Node LeftChild { get; set; }
+            public Node RightChild { get; set; }
+            public List<bool> BitString { get; set; } = new List<bool>();
+            public int Weight { get; set; }
+            public string Key { get; set; }
+
+            // Creates a leaf. So just a node is created with the given values.
+            public static Node CreateLeaf(char key, int weight) => new Node(key.ToString(), weight, null, null);
+            // Creates a branch. Here a node is created by adding the keys and weights of both childs together.
+            public static Node CreateBranch(Node leftChild, Node rightChild) => new Node(leftChild.Key + rightChild.Key, leftChild.Weight + rightChild.Weight, leftChild, rightChild);
+            private Node(string key, int weight, Node leftChild, Node rightChild)
+            {
+                this.Key = key;
+                this.Weight =  weight;
+                this.LeftChild = leftChild;
+                this.RightChild = rightChild;
+            }
+
+            public int CompareTo(Node other) => this.Weight - other.Weight;
+        }
+
+        // Node with biggest value at the top.
+        class NodePriorityList
+        {
+            public int Count => nodes.Count;
+
+            private List<Node> nodes = new List<Node>();
+
+            public NodePriorityList() { }
+            public NodePriorityList(List<Node> givenNodes)
+            {
+                this.nodes = givenNodes.ToList();
+                this.nodes.Sort();
+            }
+
+            public void Add(Node newNode)
+            {
+                var index = ~this.nodes.BinarySearch(newNode);
+                if (index == this.nodes.Count)
+                {
+                    this.nodes.Add(newNode);
+                    return;
+                }
+                this.nodes.Insert(~index, newNode);
+            }
+
+            public Node Pop()
+            {
+                var first = this.nodes.First();
+                if (first != null)
+                    this.nodes.Remove(first);
+                return first;
+            }
+        }
+
+        public static EncodingResult Encode(string input)
+        {
+            var root = CreateTree(input);
+            var dictionary = CreateDictionary(root);
+            var bitString = CreateBitString(input, dictionary);
+
+            return new EncodingResult(bitString, dictionary, root);
+        }
+
+        public static string Decode(EncodingResult result)
+        {
+            var output = "";
+            Node currentNode = result.Tree;
+            foreach (var boolean in result.BitString)
+            {
+                // Go down the tree.
+                if (!boolean)
+                    currentNode = currentNode.LeftChild;
+                else
+                    currentNode = currentNode.RightChild;
+
+                // Check if it's a leaf node.
+                if (currentNode.Key.Count() == 1)
+                {                    
+                    output += currentNode.Key;
+                    currentNode = result.Tree;
+                }
+            }
+            return output;
+        }
+
+        private static Node CreateTree(string input)
+        {
+            // Create a List of all characters and their count in input by putting them into nodes.
+            var nodes = input
+                .GroupBy(c => c)
+                .Select(n => Node.CreateLeaf(n.Key, n.Count()))
+                .ToList();
+
+            // Convert list of nodes to a NodePriorityList.
+            var nodePriorityList = new NodePriorityList(nodes);
+
+            // Create Tree.
+            while (nodePriorityList.Count > 1)
+            {
+                // Pop the two nodes with the smallest weights from the nodePriorityList and create a parentNode with the CreateBranch method. (This method adds the keys and weights of the childs together.)
+                var leftChild = nodePriorityList.Pop();
+                var rightChild = nodePriorityList.Pop();
+                var parentNode = Node.CreateBranch(leftChild, rightChild);
+
+                nodePriorityList.Add(parentNode);
+            }
+
+            return nodePriorityList.Pop();
+        }
+
+        private static Dictionary<char, List<bool>> CreateDictionary(Node root)
+        {
+            var dictionary = new Dictionary<char, List<bool>>();
+
+            var stack = new Stack<Node>();
+            stack.Push(root);
+            Node temp;
+
+            while (stack.Count != 0)
+            {
+                temp = stack.Pop();
+
+                if (temp.Key.Count() == 1)
+                    dictionary.Add(temp.Key[0], temp.BitString);
+                else
+                {
+                    if (temp.LeftChild != null)
+                    {
+                        temp.LeftChild.BitString.AddRange(temp.BitString);
+                        temp.LeftChild.BitString.Add(false);
+                        stack.Push(temp.LeftChild);
+                    }
+                    if (temp.RightChild != null)
+                    {
+                        temp.RightChild.BitString.AddRange(temp.BitString);
+                        temp.RightChild.BitString.Add(true);
+                        stack.Push(temp.RightChild);
+                    }
+                }
+           }
+
+           return dictionary;
+        }
+
+        private static List<bool> CreateBitString(string input, Dictionary<char, List<bool>> dictionary)
+        {
+            var bitString = new List<bool>();
+            foreach (var character in input)
+                bitString.AddRange(dictionary[character]);
+
+            return bitString;
+        }
+    }
+}

chapters/data_compression/huffman/code/cs/Program.cs

@@ -0,0 +1,40 @@
+// submitted by Julian Schacher (jspp) with help by gustorn.
+using System.Collections;
+using System.Collections.Generic;
+
+namespace HuffmanCoding
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            var result = HuffmanCoding.Encode("aaaabbbccd");
+            // Print dictionary.
+            foreach (var entry in result.Dictionary)
+            {
+                var bitString = "";
+                foreach (var value in entry.Value)
+                {
+                    if (value)
+                        bitString += "1";
+                    else
+                        bitString += "0";
+                }
+                System.Console.WriteLine(entry.Key + " " + bitString);
+            }
+            // Print bitString.
+            var readableBitString = "";
+            foreach (var boolean in result.BitString)
+            {
+                if (boolean)
+                    readableBitString += "1";
+                else
+                    readableBitString += "0";
+            }
+            System.Console.WriteLine($"{readableBitString} count: {readableBitString.Length}");
+
+            var originalString = HuffmanCoding.Decode(result);
+            System.Console.WriteLine(originalString);
+        }
+    }
+}

chapters/data_compression/huffman/huffman.md

@@ -86,4 +86,10 @@ Whether you use a stack or straight-up recursion also depends on the language, b
 {% sample lang="hs" %}
 ### Haskell
 [import, lang:"haskell"](code/haskell/huffman.hs)
+{% sample lang="cs" %}
+### C# #
+HuffmanCoding.cs
+[import, lang:"csharp"](code/cs/HuffmanCoding.cs)
+Program.cs
+[import, lang:"csharp"](code/cs/Program.cs)
 {% endmethod %}