Hola!
   He vuelto a C después de bastante tiempo y tengo una duda en un problema que ya no sé dónde está el error y era para ver si me podiais echar una mano.
  El problema es muy sencillo, quiero hacer un vector de punteros a una estructura que se llama triangle que tiene la forma:
               
 struct triangle
               {
   struct vertex *a, *b, *c; //cada uno de los vértices del triángulo//
   struct triangle * neighbours[3]; //triángulos vecinos
   struct vertex * opposingEdge[3]; //vert que completan al triangulo
   struct triangle * nextLevel; //puntero a triangulo en siguiente iteracion
               };

 Y mi idea es exactamente es tener un vector que en cada posición del vector tenga un puntero a triángulo, vector(i)=puntero a triángulo.
Entonces para hacerlo declaro:

                struct triangle *pos_vecinos_tri[12];

Y con esto yo considero que hace lo que busco. Para completar los datos del vector de punteros a triángulo pos_vecinos hago:
         
                   for (int y=0;y<3;y++){
                        if ((lista_tri_antigua+posicion_padre)->neighbours[y]!=NULL) {
                                pos_vecinos_tri[pos++]=(lista_tri_antigua+posicion_padre)->neighbours[y]->nextLevel;
                                pos_vecinos_tri[pos++]=((lista_tri_antigua+posicion_padre)->neighbours[y]->nextLevel)+1;
                                pos_vecinos_tri[pos++]=((lista_tri_antigua+posicion_padre)->neighbours[y]->nextLevel)+2;
                                pos_vecinos_tri[pos++]=((lista_tri_antigua+posicion_padre)->neighbours[y]->nextLevel)+3;
                        }


                    }

Es decir, a cada posicion pos_vecinos[pos] le asigno un puntero a triángulo. Según mis comprobaciones esto lo hace correctamente, cada casilla del vector tendrá entonces un puntero al triángulo que busco. El problema viene a la hora de hacer una búsqueda en ese vector. Es un vector de posibles triángulos vecinos al triángulo en cuestión, es decir triángulos que compartan 2 vértices (para ser considerados vecinos). Y la idea es dentro de ese vector de posibles triángulos vecinos (cuyos valores son correctos) buscar el triángulo que comparta dos vértices con el triángulo al cual le estoy buscando vecinos. Este triángulo será único y una vez que lo encuentre habrá de devolverme ese puntero al triángulo vecino. Es realmente sencillo pero no sé dónde falla. La búsqueda la hago de la forma:
       creo una dupla que es una estructura con dos valores dupla.x, dupla.y que serán los vértices del triángulo al que busco vecinos. En este caso del triángulo A al que busco vecinos dupla.x=puntero al vértice 1 del triángulo, dupla.y=puntero al vértice 2. Ahora me interesa buscar en el vector de posibles vecinos del triángulo un triángulo que comparta los dos vértices con dupla y para ello hago algo tan simple como:



                   for (int t=0;t<pos;t++){
                        if ( ((dupla.x==pos_vecinos_tri[t]->a) && (dupla.y==pos_vecinos_tri[t]->b))
                            || ((dupla.x==pos_vecinos_tri[t]->b) && (dupla.y==pos_vecinos_tri[t]->c))
                            || ((dupla.x==pos_vecinos_tri[t]->a) && (dupla.y==pos_vecinos_tri[t]->c))
                            || ((dupla.x==pos_vecinos_tri[t]->c) && (dupla.y==pos_vecinos_tri[t]->a))
                            || ((dupla.x==pos_vecinos_tri[t]->b) && (dupla.y==pos_vecinos_tri[t]->a))
                            || ((dupla.x==pos_vecinos_tri[t]->c) && (dupla.y==pos_vecinos_tri[t]->b)))
                        {
                            vecino=pos_vecinos_tri[t];
                            t=pos; //encontró el vecino, paramos el for
                        }
                        else vecino=NULL;
 }

Es decir estoy buscando en el vector de posibles vecinos un triángulo que comparta dos vértices y así sabré que es vecino (al compartir una arista) y engloba todos los casos posibles así que debería funcionar bien. Mi duda entonces es:
         Tengo un vector de punteros a triángulo con los valores correctos. pos tiene el número correcto de valores válidos en el vector.
         Hago una búsqueda en ese vector del triángulo que tendrá dos vértices comunes, que está obligatoriamente en esa lista. Sin embargo el resultado es que siempre vecino==NULL, nunca lo encuentra y ese triángulo sí que está en esa lista. Si alguien me pudiera decir dónde está el fallo lo agradecería eternamente, llevo tiempo ahí atascado y sé que el error tiene que ser un detalle pequeño pero se me escapa.
  Igual es que hago mal la búsqueda pero no veo el fallo. También tengo el método que funciona bien pero en vez de con vectores de punteros a triángulo coge como argumento un puntero a triángulo (apunta al primero de la lista de triángulos y lo hace bien). No me funciona, igual es que no lo llamo bien, el método es:

struct triangle * buscar_vecinos (struct triangle *lv,struct par dupla, int m, int num_triangulos){

        struct triangle *s=lv;
     
 
       for (int i=m;i<num_triangulos-1;i++){
                if ( ((dupla.x==s->a) && (dupla.y==s->b))
                    || ((dupla.x==s->b) && (dupla.y==s->c))
                    || ((dupla.x==s->a) && (dupla.y==s->c))
                    || ((dupla.x==s->c) && (dupla.y==s->a))
                    || ((dupla.x==s->b) && (dupla.y==s->a))
                    || ((dupla.x==s->c) && (dupla.y==s->b)))
                {

                            return(s);

             
                }


                s++;


       }

        return(NULL);
    }  /*fin de buscar_vecinos */


Y lo llamo como vecino=buscar_vecinos(pos_vecinos_tri[0],dupla,0,12+1), con la esperanza de que actúe igual que si le paso el puntero al primer elemento de una lista de punteros a triángulo. No me da resultado válido pero SÍ funciona pasándole como primer parámetro el puntero al primer elemento de una lista de punteros a triángulo. No sé en qué lo llamo mal para que no de resultado correcto si de la otra forma sí lo da.
  Hacer una llamada correcta al método o ver en qué falla mi bucle anterior me valdría para que todo funcione.
 
Muchas gracias por la atención