Best way to parallelize a big linked list - c

Question

I dont have any experience with parallelism. So, if you could help me it would be really amazing.
I developed a code in C and this part of the code takes 99% of the execution time.
h is a linked list, a really long linked list.
g = h;
while(g != NULL){
f = g->next;
t = g;
while(f != NULL){
if(SomeFastBooleanFunction(g, f)){
fastMergeInformationsInG(g,f);
t->next = f->next;
free(f);
f = t->next;
}
else{
t = f;
f = f->next;
}
}
g = g->next;
}
The biggest problem here is the lenght of the linked list that is really big (approximated n!2^{binomial{n}{2}} and n >= 9). Any ideas are wellcome.
Thanks a lot.
------------ UPDATE -----------------
I will put here the real code used. The function above is the cleanIso bellow. I didn't put the checkIso funcion, but this function is a optimized function that check is f is isomorphic to g.
struct Graph{
SomeInfo
int *edges;
struct Graph *next;
};
graph *cleanIso(graph *g){
graph *f1, *f2, *f3;
f1 = g;
while(f1 != NULL){
f2 = f1;
f3 = f1->next;
while(f3 != NULL){
if(checkColorIso(f1, f3)){
f1->nHom += f3->nHom;
f2->next = f3->next;
free(f3->edges);
free(f3);
f3 = f2->next;
}
else{
f2 = f3;
f3 = f3->next;
}
}
f1 = f1->next;
}
return g;
}
int checkColorIso(graph *g, graph *f){
graph *h;
int r = 0;
int v[3] = {1, 2, 3};
int nP = g->size*(g->size - 1)/2;
int a[3], b[3];
//Initializing
a[0] = 0;
a[1] = 0;
a[2] = 0;
b[0] = 0;
b[1] = 0;
b[2] = 0;
//It just check if it there is some color bijection that maybe produce a isormophism
for(int i = 0; i < g->size*(g->size - 1)/2; i++){
a[g->edges[i]-1]++;
b[f->edges[i]-1]++;
}
do{
if(a[0] == b[v[0]-1] && a[1] == b[v[1]-1] && a[2] == b[v[2]-1]){
r++;
}
}while(std::next_permutation(v, v+3));
if(r == 0)
return 0;
r = 0;
h = initializeGraph(g->size, NULL);
do{
copyGraph(f, h);
for(int i = 0; i < nP; i++)
h->edges[i] = v[h->edges[i] - 1];
r = checkIso(g, h);
}while(std::next_permutation(v, v+3) && r == 0);
free(h->edges);
free(h);
return r;
}