Add Huffman in C#.

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

@@ -0,0 +1,168 @@
+// submitted by Julian Schacher (jspp), thanks to gustorn for the help
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace HuffmanCoding
+{
+ public class EncodingResult 
+ {
+ public string BitString { get; set; }
+ public Dictionary<char, string> Dictionary { get; set; }
+ public HuffmanCoding.Node Tree { get; set; }
+
+ public EncodingResult(string bitString, Dictionary<char, string> dictionary, HuffmanCoding.Node tree)
+ {
+ this.BitString = bitString;
+ this.Dictionary = dictionary;
+ this.Tree = tree;
+ }
+ }
+
+ public 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 string BitString { get; set; } = "";
+ public int Weight { get; set; }
+ public string Key { get; set; }
+
+ public bool IsLeaf => LeftChild == null && RightChild == null;
+
+ // 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 < 0)
+ this.nodes.Insert(~index, newNode);
+ else
+ this.nodes.Insert(index, newNode);
+ }
+
+ public Node Pop()
+ {
+ var result = this.nodes[0];
+ this.nodes.RemoveAt(0);
+ return result;
+ }
+ }
+
+ public EncodingResult Encode(string input)
+ {
+ var root = CreateTree(input);
+ var dictionary = CreateDictionary(root);
+ var bitString = CreateBitString(input, dictionary);
+
+ return new EncodingResult(bitString, dictionary, root);
+ }
+
+ public string Decode(EncodingResult result)
+ {
+ var output = "";
+ Node currentNode = result.Tree;
+ foreach (var bit in result.BitString)
+ {
+ // Go down the tree.
+ if (bit == '0')
+ currentNode = currentNode.LeftChild;
+ else
+ currentNode = currentNode.RightChild;
+
+ if (currentNode.IsLeaf)
+ { 
+ output += currentNode.Key;
+ currentNode = result.Tree;
+ }
+ }
+ return output;
+ }
+
+ private 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 Dictionary<char, string> CreateDictionary(Node root)
+ {
+ // We're using a string instead of a actual bits here, since it makes the code somewhat more readable and this is an educational example. 
+ var dictionary = new Dictionary<char, string>();
+ CreateDictionary(root, "", dictionary);
+ return dictionary;
+
+ void CreateDictionary(Node node, string bitString, Dictionary<char, string> localDictionary)
+ {
+ if (node.IsLeaf)
+ localDictionary.Add(node.Key[0], bitString);
+ else
+ {
+ if (node.LeftChild != null)
+ CreateDictionary(node.LeftChild, bitString + '0', localDictionary);
+ if (node.RightChild != null)
+ CreateDictionary(node.RightChild, bitString + '1', localDictionary);
+ }
+ }
+ }
+
+
+ private string CreateBitString(string input, Dictionary<char, string> dictionary)
+ {
+ // We're using a string right here. While no compression is achieved with a string, it's the easiest way to display what the compressed result looks like. Also this is just an educational example.
+ var bitString = "";
+ foreach (var character in input)
+ bitString += dictionary[character];
+
+ return bitString;
+ }
+ }
+}

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

@@ -0,0 +1,25 @@
+// submitted by Julian Schacher (jspp), thanks to gustorn for the help
+using System.Collections;
+using System.Collections.Generic;
+
+namespace HuffmanCoding
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ var huffmanCoding = new HuffmanCoding();
+
+ var result = huffmanCoding.Encode("bibbity bobbity");
+ // The bitStrings are just strings and provide no compression. Look in HuffmanCoding.cs for explanation.
+ // Print dictionary.
+ foreach (var entry in result.Dictionary)
+ System.Console.WriteLine($"{entry.Key} {entry.Value}");
+ // Print BitString.
+ System.Console.WriteLine($"{result.BitString} count: {result.BitString.Length}");
+
+ var originalString = huffmanCoding.Decode(result);
+ System.Console.WriteLine(originalString);
+ }
+ }
+}

chapters/data_compression/huffman/huffman.md

@@ -66,6 +66,12 @@ 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)
 {% sample lang="cpp" %}
 ### C++
 [import, lang:"c_cpp"](code/c++/huffman.cpp)