Merge pull request ZoranPandovski#22 from sayak119/master

Kruskal's algorithm added and updated readme

README.md

@@ -17,12 +17,16 @@ Clean examples implementations of data structures and algorithms written in diff
   * [russian peasant](math/russian_peasant)
   * [towers_of_hanoi](math/towers_of_hanoi)
   * [armstrong_number](math/armstrong_number)
+  * [euclid's gcd](math/euclids_gcd)
+  * [prime seive](math/prime_seive)
   * [strong_number](math/strong_number)
+
 * [Cryptography](cryptography)
   * [caesar cipher](cryptography/caesar_cipher)
   * [substitution cipher](cryptography/substitution_cipher)
 * [Greedy](greedy)
   * [dijkstra’s algorithm](greedy/dijkstra’s_algorithm)
+  * [kruskal's algorithm](greedy/kruskal's_algorithm)
 * [Graphs](graphsearch)
   * [breadth-first-search](graphsearch/breadth-first-search)
   * [depth-first-search](graphsearch/depth-first-search)

greedy/kruskal's_algorithm/README.md

@@ -0,0 +1,9 @@
+### Kruskal’s algorithm
+What is Minimum Spanning Tree?
+Given a connected and undirected graph, a spanning tree of that graph is a subgraph that is a tree and connects all the vertices together. A single graph can have many different spanning trees. A minimum spanning tree (MST) or minimum weight spanning tree for a weighted, connected and undirected graph is a spanning tree with weight less than or equal to the weight of every other spanning tree. The weight of a spanning tree is the sum of weights given to each edge of the spanning tree.
+
+Kruskal's algorithm is a minimum-spanning-tree algorithm which finds an edge of the least possible weight that connects any two trees in the forest.[1] It is a greedy algorithm in graph theory as it finds a minimum spanning tree for a connected weighted graph adding increasing cost arcs at each step.[1] This means it finds a subset of the edges that forms a tree that includes every vertex, where the total weight of all the edges in the tree is minimized. If the graph is not connected, then it finds a minimum spanning forest (a minimum spanning tree for each connected component).
+
+
+#### A graphical example of Kruskal’s algorithm
+![](https://upload.wikimedia.org/wikipedia/commons/5/5c/MST_kruskal_en.gif)

greedy/kruskal's_algorithm/c++/kruskals_algorithm.c++

@@ -0,0 +1,181 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// a structure to represent a weighted edge in graph
+struct Edge
+{
+	int src, dest, weight;
+};
+
+// a structure to represent a connected, undirected and weighted graph
+struct Graph
+{
+	// 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.
+	struct Edge* edge;
+};
+
+// Creates a graph with V vertices and E edges
+struct Graph* createGraph(int V, int E)
+{
+	struct Graph* graph = (struct Graph*) malloc( sizeof(struct Graph) );
+	graph->V = V;
+	graph->E = E;
+
+	graph->edge = (struct Edge*) malloc( graph->E * sizeof( struct Edge ) );
+
+	return graph;
+}
+
+// A structure to represent a subset for union-find
+struct subset
+{
+	int parent;
+	int rank;
+};
+
+// A utility function to find set of an element i
+// (uses path compression technique)
+int find(struct 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(struct 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)
+{
+	struct Edge* a1 = (struct Edge*)a;
+	struct Edge* b1 = (struct Edge*)b;
+	return a1->weight > b1->weight;
+}
+
+// The main function to construct MST using Kruskal's algorithm
+void KruskalMST(struct Graph* graph)
+{
+	int V = graph->V;
+	struct 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
+	struct subset *subsets =
+		(struct subset*) malloc( V * sizeof(struct 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)
+	{
+		// Step 2: Pick the smallest edge. And increment the index
+		// for next iteration
+		struct 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
+	printf("Following are the edges in the constructed MST\n");
+	for (i = 0; i < e; ++i)
+		printf("%d -- %d == %d\n", result[i].src, result[i].dest,
+				result[i].weight);
+	return;
+}
+
+// Test program
+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
+	struct 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;
+}

euclids-gcd.c → math/euclids_gcd/c/euclids_gcd.c

@@ -1,10 +1,11 @@
+#include<stdio.h>
 int gcd(int a, int b)
 {
     if (a == 0)
         return b;
     return gcd(b%a, a);
 }
- 
+
 // Driver program to test above function
 int main()
 {