并行化大型链表的最佳方法

Question

我没有任何并行经验。所以，如果你能帮助我，那将是非常了不起的。

我在C中开发了一个代码，这部分代码占用了99％的执行时间。

h是一个链表，一个非常长的链表。

    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;
     }

这里最大的问题是链表的长度非常大（近似n！2 ^ {二项式{n} {2}}和n＆gt; = 9）。任何想法都很好。

非常感谢。

------------ UPDATE -----------------

我将把这里使用的真实代码放在这里。上面的功能是cleanIso如下。我没有把checkIso函数，但是这个函数是一个优化函数，检查f是与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;                                                                                                                                                                                                 
    }