adding huffman_coding.cpp

Author: mandliya

README.md

@@ -178,13 +178,15 @@ Include contains single header implementation of data structures and some algori
 | calculate the shortest distance from the start position (Node S) to all of the other nodes in the graph using Dijkstra algorithm. | [dijkstra-shortest-reach.cpp](graph_problems/dijkstra-shortest-reach.cpp)|
 | Calculate total weight of Minimum Spanning Tree of a given graph ( sum of weights of edges which forms MST) using Prim's algorithm | [primsMST.cpp](graph_problems/primsMST.cpp)|
 | Print Minimum Spanning Tree( MST ) of a given graph using Kruskal's algorithm.| [kruskalMST.cpp](graph_problems/kruskalMST.cpp)|
+| Create a program to generate a Huffman encoding for each character as a table.|[huffman_encoding.cpp] (greedy_problems/huffman_encoding.cpp)|
 
 ### Greedy Problems
 | Problem | Solution |
 | :------------ | :----------: |
 | Given two integer arrays, A and B, each containing N integers. You are free to permute the order of the elements in the arrays. Is there an permutation A', B' possible of A and B, such that, A'<sub>i</sub>+B'<sub>i</sub> ≥ K for all i, where A'<sub>i</sub> denotes the i<sup>th</sup> element in the array A' and B'<sub>i</sub> denotes i<sup>th</sup> element in the array B'.| [two_arrays.cpp](greedy_problems/two_arrays.cpp)|
 |John is taking orders. The i<sup>th</sup> order is placed by the i<sup>th</sup> customer at t<sub>i</sub> time and it takes d<sub>i</sub> time to procees. What is the order in which the customers will get their orders? (see more details in solutions's comments)|[orders_order.cpp](greedy_problems/orders_order.cpp)|
 
+
 ### Leet code Problems
 | Problem | Solution |
 | :------------ | :----------: |

greedy_problems/huffman_coding.cpp

@@ -0,0 +1,100 @@
+/**
+ * Huffman Encoding:
+ * Huffman coding compresses data by using fewer bits to encode more frequently
+ * occurring characters so that not all characters are encoded with 8 bits.
+ * It is a way to assign binary codes to symbols that reduces the overall number of bits
+ * used to encode a typical string of those symbols. 
+ * For example, if you use letters as symbols and have details of the frequency of occurrence
+ * of those letters in typical strings, then you could just encode each letter with a fixed number of bits,
+ * such as in ASCII codes. You can do better than this by encoding more frequently occurring letters such as e and a,
+ * with smaller bit strings; and less frequently occurring letters such as q and x with longer bit strings.
+ * More details: https://www.cs.duke.edu/csed/poop/huff/info/
+ */
+
+#include <iostream>
+#include <queue>
+#include <vector>
+
+struct HeapNode
+{
+    char data;
+    unsigned int frequency;
+    HeapNode *left;
+    HeapNode *right;
+
+    HeapNode(char d, unsigned int fr)
+    : data {d},
+      frequency {fr},
+      left {nullptr},
+      right {nullptr}
+    {}
+};
+
+// We need a comparator for comparing two nodes.
+struct compare
+{
+    bool operator() (HeapNode* node1, HeapNode* node2)
+    {
+        return (node1->frequency > node2->frequency);
+    }
+};
+
+void generateHuffmanCodeUtil(HeapNode* root, std::string str)
+{
+    if (!root)
+        return;
+    
+    if (root->data != '$')
+    {
+        std::cout << root->data << " : " << str << std::endl;
+    }
+
+    generateHuffmanCodeUtil(root->left, str + '0');
+    generateHuffmanCodeUtil(root->right, str + '1');
+}
+
+void generateHuffmanCode(std::string data, std::vector<int> frequencies)
+{
+    HeapNode *left, *right, *top;
+
+    // Create a minimum heap based on frequency and inserts all characters in it.
+    //
+    std::priority_queue<HeapNode*, std::vector<HeapNode*>, compare> minHeap;
+    unsigned int size = frequencies.size();
+    for (unsigned int i = 0; i < size; ++i)
+    {
+        minHeap.push(new HeapNode(data[i], frequencies[i]));
+    }
+
+    while (minHeap.size() != 1)
+    {
+        // Get two minimum nodes from heap.
+        left = minHeap.top();
+        minHeap.pop();
+
+        right = minHeap.top();
+        minHeap.pop();
+
+        // Combine the above two nodes (their frequecies) to generate a
+        // new node.Make these two nodes as left and right children of this new node. 
+        // Add this node to the min heap, also assign in '$' as data. (character for internal nodes)
+        //
+        top = new HeapNode('$', left->frequency + right->frequency);
+        top->left = left;
+        top->right = right;
+        minHeap.push(top);
+    }
+
+    // We are done generating the tree, lets print it.
+    //
+    generateHuffmanCodeUtil(minHeap.top(), "");
+}
+
+int main()
+{
+    std::string data{"abcdef"};
+    std::vector<int> frequencies = { 5, 9, 12, 13, 16, 45 };
+
+    generateHuffmanCode(data, frequencies);
+    return 0;
+}