adding kruskals algorithm

algorithms/heap_sort/Python/heapSort.py

@@ -0,0 +1,47 @@
+__author__ = 'mittr'
+    # To heapify subtree rooted at index i.
+    # n is size of heap
+    def heapify(arr, n, i):
+        largest = i  # Initialize largest as root
+        l = 2 * i + 1     # left = 2*i + 1
+        r = 2 * i + 2     # right = 2*i + 2
+
+        # See if left child of root exists and is
+        # greater than root
+        if l < n and arr[i] < arr[l]:
+            largest = l
+
+        # See if right child of root exists and is
+        # greater than root
+        if r < n and arr[largest] < arr[r]:
+            largest = r
+
+        # Change root, if needed
+        if largest != i:
+            arr[i],arr[largest] = arr[largest],arr[i]  # swap
+
+            # Heapify the root.
+            heapify(arr, n, largest)
+
+    # The main function to sort an array of given size
+
+
+    def heapSort(arr):
+        n = len(arr)
+
+        # Build a maxheap.
+        for i in range(n, -1, -1):
+            heapify(arr, n, i)
+
+        # One by one extract elements
+        for i in range(n-1, 0, -1):
+            arr[i], arr[0] = arr[0], arr[i]   # swap
+            heapify(arr, i, 0)
+
+    # Driver code to test above
+    arr = [12, 11, 13, 5, 6, 7]
+    heapSort(arr)
+    n = len(arr)
+    print("Sorted array is")
+    for i in range(n):
+        print("%d" %arr[i])

algorithms/kruskal/kruskals.cpp

@@ -0,0 +1,133 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class Edge {
+public:
+    int src, dest, weight;
+};
+
+class Graph {
+public:
+
+    int V, E;
+    Edge* edge;
+};
+
+Graph* createGraph(int V, int E) {
+    Graph* graph = new Graph;
+    graph->V = V;
+    graph->E = E;
+
+    graph->edge = new Edge[E];
+
+    return graph;
+}
+
+class subset {
+public:
+    int parent;
+    int rank;
+};
+
+int find(subset subsets[], int i) {
+    if (subsets[i].parent != i)
+        subsets[i].parent
+            = find(subsets, subsets[i].parent);
+
+    return subsets[i].parent;
+}
+
+void Union(subset subsets[], int x, int y) {
+    int xroot = find(subsets, x);
+    int yroot = find(subsets, y);
+
+    if (subsets[xroot].rank < subsets[yroot].rank)
+        subsets[xroot].parent = yroot;
+    else if (subsets[xroot].rank > subsets[yroot].rank)
+        subsets[yroot].parent = xroot;
+
+    else {
+        subsets[yroot].parent = xroot;
+        subsets[xroot].rank++;
+    }
+}
+
+int myComp(const void* a, const void* b) {
+    Edge* a1 = (Edge*)a;
+    Edge* b1 = (Edge*)b;
+    return a1->weight > b1->weight;
+}
+
+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
+
+    qsort(graph->edge, graph->E, sizeof(graph->edge[0]), myComp);
+
+    subset* subsets = new subset[(V * sizeof(subset))];
+
+    for (int v = 0; v < V; ++v) {
+        subsets[v].parent = v;
+        subsets[v].rank = 0;
+    }
+
+    while (e < V - 1 && i < graph->E) {
+        Edge next_edge = graph->edge[i++];
+
+        int x = find(subsets, next_edge.src);
+        int y = find(subsets, next_edge.dest);
+        if (x != y) {
+            result[e++] = next_edge;
+            Union(subsets, x, y);
+        }
+    }
+
+    cout << "Following are the edges in the constructed MST\n";
+    int minimumCost = 0;
+    for (i = 0; i < e; ++i)
+    {
+        cout << result[i].src << " -- " << result[i].dest
+             << " == " << result[i].weight << endl;
+        minimumCost = minimumCost + result[i].weight;
+    }
+    cout << "Minimum Cost Spanning Tree: " << minimumCost<< endl;
+}
+
+// Driver code
+int main() {
+    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;
+}