Kruskal algorithm in C

The greedy Kruskal's method searches for the quickest route through a connected weighted network. In this algorithm, we start with an empty set of edges and add edges to the set one at a time until we obtain a spanning tree.

Kruskal's approach is a well-known algorithm for determining the shortest spanning tree in a linked, weighted network. A minimum spanning tree is a tree that joins every node in a graph using the fewest possible total edge weights.

The algorithm considers all edges of the graph in ascending weight order and adds them to the minimum spanning tree if they do not form a cycle with the edges already in the tree. Kruskal's approach employs the disjoint-set data structure to prevent the formation of cycles.

Characteristics:

If an edge does not form a cycle with edges already in the tree, the method evaluates all edges of the graph in ascending weight order and adds them to the minimal spanning tree.
The algorithm maintains a set of disjoint subsets of vertices, with each subset representing a connected component of the graph. As edges are added to the selected set, the subsets are merged together, until all vertices belong to the same subset.

Usage:

Kruskal's algorithm can be used in a variety of applications, such as network design, clustering, and image segmentation. It is frequently used in engineering, computer science, and other disciplines that call for graph analysis.

The Kruskal algorithm's steps are listed below:

Sort all the edges according to weight in a non-decreasing order.
Initialize an empty set for the minimum spanning tree and an empty disjoint-set data structure.
Add the edge to the tree and combine the two sets that the edge's endpoints belong to in the disjoint-set data structure for each edge in the sorted order if doing so does not result in a cycle.
Until all edges have been taken into account or the smallest spanning tree has n-1 edges-where n is the number of nodes in the graph-repeat step 3 as necessary.
At the end of the algorithm, the minimum spanning tree will be the set of edges added to the tree in step 3. The temporal complexity of Kruskal's algorithm, where E is the number of edges and V is the number of vertices in the graph, is either O(ElogE) or O(ElogV).

Here is the implementation of Kruskal's algorithm in C:

C Program:

#include <stdio.h>
#include <stdlib.h>

#define MAX_EDGES 1000

typedef struct Edge {
    int src, dest, weight;
} Edge;

typedef struct Graph {
    int V, E;
    Edge edges[MAX_EDGES];
} Graph;

typedef struct Subset {
    int parent, rank;
} Subset;

Graph* createGraph(int V, int E) {
    Graph* graph = (Graph*) malloc(sizeof(Graph));
    graph->V = V;
    graph->E = E;
    return graph;
}

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 compare(const void* a, const void* b) {
    Edge* a_edge = (Edge*) a;
    Edge* b_edge = (Edge*) b;
    return a_edge->weight - b_edge->weight;
}

void kruskalMST(Graph* graph) {
    Edge mst[graph->V];
    int e = 0, i = 0;

    qsort(graph->edges, graph->E, sizeof(Edge), compare);

    Subset* subsets = (Subset*) malloc(graph->V * sizeof(Subset));
    for (int v = 0; v < graph->V; ++v) {
        subsets[v].parent = v;
        subsets[v].rank = 0;
    }

    while (e < graph->V - 1 && i < graph->E) {
        Edge next_edge = graph->edges[i++];

        int x = find(subsets, next_edge.src);
        int y = find(subsets, next_edge.dest);

        if (x != y) {
            mst[e++] = next_edge;
            Union(subsets, x, y);
        }
    }

    printf("Minimum Spanning Tree:\n");
    for (i = 0; i < e; ++i) {
        printf("(%d, %d) -> %d\n", mst[i].src, mst[i].dest, mst[i].weight);
    }
}

int main() {
    int V, E;
    printf("Enter number of vertices and edges: ");
    scanf("%d %d", &V, &E);

    Graph* graph = createGraph(V, E);

    printf("Enter edges and their weights:\n");
    for (int i = 0; i < E; ++i) {
        scanf("%d %d %d", &graph->edges[i].src, &graph->edges[i].dest, &graph->edges[i].weight);
    }

    kruskalMST(graph);

    return 0;
}

This code reads in the number of vertices and edges of a graph, as well as the edges and their weights, from the user. It then runs Kruskal's algorithm on the graph and prints out the minimum spanning tree.

Input and output for the Kruskal's algorithm implementation in C:

Input:

Enter number of vertices and edges: 5 7
Enter edges and their weights:
1 2
3 6
2 3
3 8
4 5
4 7
4 9

Output:

Minimum Spanning Tree:
(0, 1) -> 2
(1, 2) -> 3
(1, 4) -> 5
(0, 3) -> 6

In this example, the input specifies a graph with 5 vertices and 7 edges. The edge weights are then read in from the user. Kruskal's algorithm's output displays the edges that make up the minimal spanning tree.

Advantages:

Kruskal's algorithm is simple to implement and understand.
It finds the minimum spanning tree of a graph in a reasonable amount of time, making it suitable for large graphs.
The algorithm is suitable for a wide range of applications.

Disadvantages:

The algorithm may not find the unique minimum spanning tree of a graph, since there may be multiple minimum spanning trees with the same total weight.
The algorithm requires sorting the edges of the graph by weight, which can be time-consuming for large graphs.
The algorithm requires extra space to store the disjoint subsets of vertices.

Conclusion:

The Kruskal algorithm is a straightforward and effective method for determining a graph's least spanning tree. E is the number of edges in the graph, and its temporal complexity is O(E log E). It is hence appropriate for huge graphs.

Next TopicTranspose of Matrix in C

← prev next →