A
   /| \
  2 |  4
 /  |   \
B---3---C---1---D
 |     / |     / |
 5   8   2   7   6
 | /     | /     |
E-------4-------F

#include<stdio.h>
#define V 6

int parent[V];

int find(int x) {
    if(parent[x] == x) return x;
    return parent[x] = find(parent[x]);  // Path compression
}

void unionSets(int x, int y) {
    int px = find(x), py = find(y);
    if(px != py) parent[px] = py;
}

typedef struct {
    int u, v, wt;
} Edge;

void kruskal(Edge edges[], int E) {
    for(int i=0; i<V; i++) parent[i] = i;

    Edge mst[V-1];
    int count = 0, cost = 0, idx = 0;

    // Sort edges by weight (manual sort for exam)
    // Assume edges are already sorted

    while(count < V-1 && idx < E) {
        Edge e = edges[idx++];
        int pu = find(e.u), pv = find(e.v);
        if(pu != pv) {
            unionSets(e.u, e.v);
            mst[count++] = e;
            cost += e.wt;
            printf("Added: %c-%c (wt=%d)\n", 'A'+e.u, 'A'+e.v, e.wt);
        }
    }
    printf("Total MST Cost = %d\n", cost);
}

int main() {
    Edge edges[] = {
        {2,3,1}, {0,1,2}, {1,2,3}, {4,5,4}, {1,4,5},
        {0,2,4}, {3,5,6}, {3,4,7}, {2,4,8}
    };
    int E = 9;

    printf("Kruskal's MST:\n");
    kruskal(edges, E);
    return 0;
}

Kruskal's MST:
Added: C-D (wt=1)
Added: A-B (wt=2)
Added: B-C (wt=3)
Added: E-F (wt=4)
Added: B-E (wt=5)
Total MST Cost = 16

#include<stdio.h>
#include<stdbool.h>
#define INF 99999

void prim(int graph[V][V]) {
    int key[V], parent[V];
    bool inMST[V] = {false};

    for(int i=0; i<V; i++) key[i] = INF;
    key[0] = 0; parent[0] = -1;

    for(int count=0; count<V; count++) {
        // Find min key vertex not in MST
        int min = INF, u = -1;
        for(int i=0; i<V; i++)
            if(!inMST[i] && key[i] < min) {
                min = key[i]; u = i;
            }

        inMST[u] = true;
        if(parent[u] != -1)
            printf("Added: %c-%c (wt=%d)\n", 'A'+parent[u], 'A'+u, min);

        // Update neighbors
        for(int v=0; v<V; v++) {
            if(graph[u][v] && !inMST[v] && graph[u][v] < key[v]) {
                key[v] = graph[u][v];
                parent[v] = u;
            }
        }
    }
}

int main() {
    int graph[V][V] = {
        {0,2,4,0,0,0},
        {2,0,3,0,5,0},
        {4,3,0,1,8,0},
        {0,0,1,0,7,6},
        {0,5,8,7,0,4},
        {0,0,0,6,4,0}
    };

    printf("Prim's MST (starting from A):\n");
    prim(graph);
    return 0;
}

Prim's MST (starting from A):
Added: A-B (wt=2)
Added: B-C (wt=3)
Added: C-D (wt=1)
Added: B-E (wt=5)
Added: E-F (wt=4)