Mensajes

Ok, muchas gracias. He adaptado tu función a la mía, puesto que ha de hacerse por duplas pues un triángulo puede tener hasta tres vecinos (uno por cada arista) y sigue sin ir, al menos aprendí bien cómo pasar una vector de punteros a una función.
  Como creo que lo que dices es correcto y juraría que lo que tenía antes también repasaré la creación de ese vector de punteros porque aunque crea que está bien tiene que haber un error en algún lado y aunque lo daba por bueno lo anterior tiene que estar antes de la búsqueda porque si no se explica. Gracias de nuevo por tu tiempo, iré haciendo a mano los cálculos y ver dónde puede estar.

[dupla.x == s->b]

Hola, bueno en el codigo veo que se hacen comparaciones como la siguiente:

dupla.x == s->b

alli dupla.x y s->b son punteros, osea que se están comparando punteros, talves el problema este siendo originado por que en lugar de comparar punteros deberias comparar los valores a los que estos apuntan.

Para ponerlo más sencillo, si se hace la declaración:

int n=2,m=2;

luego n==m es verdadero y &n==&m es falso

pienso que talves hayas pasado eso por alto.

Saludos

Muchas gracias por la respuesta pero he comprobado y sigue sin encontrar nada. Lo había puesto así ya que en el programa existe una única copa en memoria de cada vértice y entonces si apunta a éste llegaría para saber que son el mismo valor pero aún así acabo de comprobarlo haciendo las comparaciones a pelo con los valores no con la dirección de memoria y sigue igual.

He comprobado mil veces que el vector sí tiene el elemento que busca pero por algo que no veo en la búsqueda no lo encuentra. A ver si alguien viera el fallo porque tiene que ser una cosa pequeña pero no la doy visto. Gracias de todos modos.

[pos]

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