Best way to implement a graph without STL? - data-structures

Question

I have been assigned a project where i must take in a bunch of nodes, as well as edges with weights between certain nodes.
I must then use this information to find a minimal spanning tree for each connected component of the graph (so if the graph has two connected components i need to create two spanning trees)
The catch is i cannot use any STL libraries except for .
I know i will need to create my own data structures but i don't know which ones i will need. I suppose a minimum heap would be useful for finding the lowest weight edges to use but how would i go about creating a min heap for each connected component?
And i was thinking i need to implement union-find in order to organize the sets of connected components.
what other data structures would i need to implement for this?

Answer 1

For union-find you need to implement DISJOINT SET.
here is simple implementation using simple arrays.. have a look
// Disjoint Set implementation
// Shashank Jain
#include<iostream>
#define LL long long int
#define LIM 100005
using namespace std;
int p[LIM],n; // p is for parent
int rank[LIM];
void create_set()
{
for(int i=1;i<=n;i++)
{
p[i]=i;
rank[i]=0;
}
}
int find_set(int x)
{
if(x==p[x])
return x;
else
{
p[x]=find_set(p[x]);
return p[x];
}
}
void merge_sets(int x,int y)
{
int px,py;
px=find_set(x);
py=find_set(y);
if(rank[px]>rank[py])
p[py]=px;
else
if(rank[py]>rank[px])
p[px]=py;
else
if(rank[px]==rank[py])
{
p[px]=py;
rank[py]++;
}
}
int main()
{
cin>>n; // no: of vertex , considering that vertex are numbered from 1 to n
create_set();
int a,b,q,i;
cin>>q; // queries
while(q--)
{
cin>>a>>b;
merge_sets(a,b);
}
for(i=1;i<=n;i++)
{
cout<<find_set(i)<<endl; // vertex having same value of find_set i.e same representative of set are in same subset
}
return 0;
}

Answer 2

I'm going to assume that you can choose your MST algorithm and that the output is a list of edges. Borůvka's algorithm is simple to implement and needs no data structures other than the graph and a disjoint set structure. By contrast, Prim's algorithm requires a priority queue and some logic to handle disconnected graphs, and Kruskal's algorithm requires a disjoint set structure and a sorting algorithm. I would set up the data structures like this. There is an adjacency record for each incident vertex-edge pair.
struct Adjacency;
struct Edge {
int weight;
};
struct Vertex {
struct Adjacency *listhead; // singly-linked list of adjacencies
struct Vertex *parent; // union-find parent
};
struct Adjacency {
struct Adjacency *listnext;
struct Edge *edge;
struct Vertex *endpoint; // the "other" endpoint
};