Added algorithms in greedy folder

Greedy/greedy algo1.cpp

@@ -0,0 +1,36 @@
+// C++ program to find minimum number of denominations 
+#include <bits/stdc++.h> 
+using namespace std; 
+
+// All denominations of Indian Currency 
+int deno[] = { 1, 2, 5, 10, 20, 50, 100, 500, 1000 }; 
+int n = sizeof(deno) / sizeof(deno[0]); 
+
+// Driver program 
+void findMin(int V) 
+{ 
+    // Initialize result 
+    vector<int> ans; 
+
+    // Traverse through all denomination 
+    for (int i = n - 1; i >= 0; i--) { 
+        // Find denominations 
+        while (V >= deno[i]) { 
+            V -= deno[i]; 
+            ans.push_back(deno[i]); 
+        } 
+    } 
+
+    // Print result 
+    for (int i = 0; i < ans.size(); i++) 
+        cout << ans[i] << "  "; 
+} 
+
+// Driver program 
+int main() 
+{ 
+    int n = 93; 
+    cout << "Following is minimal number of change for " << n << " is "; 
+    findMin(n); 
+    return 0; 
+} 

Greedy/huffman's algo.cpp

@@ -0,0 +1,106 @@
+
+// A Huffman tree node 
+struct MinHeapNode { 
+
+    // One of the input characters 
+    char data; 
+
+    // Frequency of the character 
+    unsigned freq; 
+
+    // Left and right child 
+    MinHeapNode *left, *right; 
+
+    MinHeapNode(char data, unsigned freq) 
+
+    { 
+
+        left = right = NULL; 
+        this->data = data; 
+        this->freq = freq; 
+    } 
+}; 
+
+// For comparison of 
+// two heap nodes (needed in min heap) 
+struct compare { 
+
+    bool operator()(MinHeapNode* l, MinHeapNode* r) 
+
+    { 
+        return (l->freq > r->freq); 
+    } 
+}; 
+
+// Prints huffman codes from 
+// the root of Huffman Tree. 
+void printCodes(struct MinHeapNode* root, string str) 
+{ 
+
+    if (!root) 
+        return; 
+
+    if (root->data != '$') 
+        cout << root->data << ": " << str << "\n"; 
+
+    printCodes(root->left, str + "0"); 
+    printCodes(root->right, str + "1"); 
+} 
+
+// The main function that builds a Huffman Tree and 
+// print codes by traversing the built Huffman Tree 
+void HuffmanCodes(char data[], int freq[], int size) 
+{ 
+    struct MinHeapNode *left, *right, *top; 
+
+    // Create a min heap & inserts all characters of data[] 
+    priority_queue<MinHeapNode*, vector<MinHeapNode*>, compare> minHeap; 
+
+    for (int i = 0; i < size; ++i) 
+        minHeap.push(new MinHeapNode(data[i], freq[i])); 
+
+    // Iterate while size of heap doesn't become 1 
+    while (minHeap.size() != 1) { 
+
+        // Extract the two minimum 
+        // freq items from min heap 
+        left = minHeap.top(); 
+        minHeap.pop(); 
+
+        right = minHeap.top(); 
+        minHeap.pop(); 
+
+        // Create a new internal node with 
+        // frequency equal to the sum of the 
+        // two nodes frequencies. Make the 
+        // two extracted node as left and right children 
+        // of this new node. Add this node 
+        // to the min heap '$' is a special value 
+        // for internal nodes, not used 
+        top = new MinHeapNode('$', left->freq + right->freq); 
+
+        top->left = left; 
+        top->right = right; 
+
+        minHeap.push(top); 
+    } 
+
+    // Print Huffman codes using 
+    // the Huffman tree built above 
+    printCodes(minHeap.top(), ""); 
+} 
+
+// Driver program to test above functions 
+int main() 
+{ 
+
+    char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' }; 
+    int freq[] = { 5, 9, 12, 13, 16, 45 }; 
+
+    int size = sizeof(arr) / sizeof(arr[0]); 
+
+    HuffmanCodes(arr, freq, size); 
+
+    return 0; 
+} 
+

Greedy/krushkal's algo.cpp

@@ -0,0 +1,190 @@
+// C++ program for Kruskal's algorithm to find Minimum Spanning Tree  
+// of a given connected, undirected and weighted graph  
+#include <bits/stdc++.h> 
+using namespace std; 
+
+// a structure to represent a weighted edge in graph  
+class Edge  
+{  
+    public: 
+    int src, dest, weight;  
+};  
+
+// a structure to represent a connected, undirected  
+// and weighted graph  
+class Graph  
+{  
+    public: 
+    // V-> Number of vertices, E-> Number of edges  
+    int V, E;  
+
+    // graph is represented as an array of edges.  
+    // Since the graph is undirected, the edge  
+    // from src to dest is also edge from dest  
+    // to src. Both are counted as 1 edge here.  
+    Edge* edge;  
+};  
+
+// Creates a graph with V vertices and E edges  
+Graph* createGraph(int V, int E)  
+{  
+    Graph* graph = new Graph;  
+    graph->V = V;  
+    graph->E = E;  
+
+    graph->edge = new Edge[E];  
+
+    return graph;  
+}  
+
+// A structure to represent a subset for union-find  
+class subset  
+{  
+    public: 
+    int parent;  
+    int rank;  
+};  
+
+// A utility function to find set of an element i  
+// (uses path compression technique)  
+int find(subset subsets[], int i)  
+{  
+    // find root and make root as parent of i  
+    // (path compression)  
+    if (subsets[i].parent != i)  
+        subsets[i].parent = find(subsets, subsets[i].parent);  
+
+    return subsets[i].parent;  
+}  
+
+// A function that does union of two sets of x and y  
+// (uses union by rank)  
+void Union(subset subsets[], int x, int y)  
+{  
+    int xroot = find(subsets, x);  
+    int yroot = find(subsets, y);  
+
+    // Attach smaller rank tree under root of high  
+    // rank tree (Union by Rank)  
+    if (subsets[xroot].rank < subsets[yroot].rank)  
+        subsets[xroot].parent = yroot;  
+    else if (subsets[xroot].rank > subsets[yroot].rank)  
+        subsets[yroot].parent = xroot;  
+
+    // If ranks are same, then make one as root and  
+    // increment its rank by one  
+    else
+    {  
+        subsets[yroot].parent = xroot;  
+        subsets[xroot].rank++;  
+    }  
+}  
+
+// Compare two edges according to their weights.  
+// Used in qsort() for sorting an array of edges  
+int myComp(const void* a, const void* b)  
+{  
+    Edge* a1 = (Edge*)a;  
+    Edge* b1 = (Edge*)b;  
+    return a1->weight > b1->weight;  
+}  
+
+// The main function to construct MST using Kruskal's algorithm  
+void KruskalMST(Graph* graph)  
+{  
+    int V = graph->V;  
+    Edge result[V]; // Tnis will store the resultant MST  
+    int e = 0; // An index variable, used for result[]  
+    int i = 0; // An index variable, used for sorted edges  
+
+    // Step 1: Sort all the edges in non-decreasing  
+    // order of their weight. If we are not allowed to  
+    // change the given graph, we can create a copy of  
+    // array of edges  
+    qsort(graph->edge, graph->E, sizeof(graph->edge[0]), myComp);  
+
+    // Allocate memory for creating V ssubsets  
+    subset *subsets = new subset[( V * sizeof(subset) )];  
+
+    // Create V subsets with single elements  
+    for (int v = 0; v < V; ++v)  
+    {  
+        subsets[v].parent = v;  
+        subsets[v].rank = 0;  
+    }  
+
+    // Number of edges to be taken is equal to V-1  
+    while (e < V - 1 && i < graph->E)  
+    {  
+        // Step 2: Pick the smallest edge. And increment  
+        // the index for next iteration  
+        Edge next_edge = graph->edge[i++];  
+
+        int x = find(subsets, next_edge.src);  
+        int y = find(subsets, next_edge.dest);  
+
+        // If including this edge does't cause cycle,  
+        // include it in result and increment the index  
+        // of result for next edge  
+        if (x != y)  
+        {  
+            result[e++] = next_edge;  
+            Union(subsets, x, y);  
+        }  
+        // Else discard the next_edge  
+    }  
+
+    // print the contents of result[] to display the  
+    // built MST  
+    cout<<"Following are the edges in the constructed MST\n";  
+    for (i = 0; i < e; ++i)  
+        cout<<result[i].src<<" -- "<<result[i].dest<<" == "<<result[i].weight<<endl;  
+    return;  
+}  
+
+// Driver code 
+int main()  
+{  
+    /* Let us create following weighted graph  
+            10  
+        0--------1  
+        | \ |  
+    6| 5\ |15  
+        | \ |  
+        2--------3  
+            4 */
+    int V = 4; // Number of vertices in graph  
+    int E = 5; // Number of edges in graph  
+    Graph* graph = createGraph(V, E);  
+
+
+    // add edge 0-1  
+    graph->edge[0].src = 0;  
+    graph->edge[0].dest = 1;  
+    graph->edge[0].weight = 10;  
+
+    // add edge 0-2  
+    graph->edge[1].src = 0;  
+    graph->edge[1].dest = 2;  
+    graph->edge[1].weight = 6;  
+
+    // add edge 0-3  
+    graph->edge[2].src = 0;  
+    graph->edge[2].dest = 3;  
+    graph->edge[2].weight = 5;  
+
+    // add edge 1-3  
+    graph->edge[3].src = 1;  
+    graph->edge[3].dest = 3;  
+    graph->edge[3].weight = 15;  
+
+    // add edge 2-3  
+    graph->edge[4].src = 2;  
+    graph->edge[4].dest = 3;  
+    graph->edge[4].weight = 4;  
+
+    KruskalMST(graph);  
+
+    return 0;  
+}  
+