Problema con una funcion para verificar si un elemento esta o no

[palacio29]

Tengo 2 arreglos de estructuras estaticos y tengo que crear un tercer arreglo de estructura de manera dinamica, que contenga los valores que no estan en ambos arreglos estaticos.
El problema me esta saliendo, el problema viene cuando quiero verificar para que no me pase ningun repetido.
Por eso cree la funcion esta que es una booleana, pero al poner esta funcion el programa se rompe.
No se en que le estoy pifiando.

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#define T 4
#define N 5
struct s_alumno
{
    int numero;
};
typedef struct s_alumno t_alumno;

t_alumno* CARGA (t_alumno arreglo1[T],t_alumno arreglo2[N]);
int esta(t_alumno*,int);

int main()
{
    int i=0;
    t_alumno*liston=NULL;
    t_alumno arreglo1[T];
    t_alumno arreglo2[N];
    arreglo1[0].numero=1;
    arreglo1[1].numero=7;
    arreglo1[2].numero=3;
    arreglo1[3].numero=5;

    arreglo2[0].numero=2;
    arreglo2[1].numero=8;
    arreglo2[2].numero=5;
    arreglo2[3].numero=9;
    arreglo2[4].numero=7;

    printf("Conjunto A : %d - %d - %d - %d\n", arreglo1[0].numero,arreglo1[1].numero,arreglo1[2].numero,arreglo1[3].numero);
    printf("Conjunto B : %d - %d - %d - %d - %d \n",arreglo2[0].numero,arreglo2[1].numero,arreglo2[2].numero,arreglo2[3].numero,arreglo2[4].numero);
    liston=CARGA(arreglo1,arreglo2);
    printf ("\nImprimimos Lista:\n");
    while((liston+i)->numero!=0)
    {
        printf(" %d -",(liston+i)->numero);

        i++;
    }


    return 0;
}
t_alumno* CARGA(t_alumno arreglo1[T],t_alumno arreglo2[N])
{
    int i=0,j=0,k=0,maximo=0,bandera=1;

    t_alumno* lista=NULL;
    lista=malloc(sizeof(struct s_alumno));

    for(i=0;i<T;i++)
    {

        for(j=0;j<N;j++)
        {
            if(arreglo1[i].numero==arreglo2[j].numero)
            {
                bandera=0;
            }
        }
        if(bandera==1)

        {
                if(!esta(lista,arreglo1[i].numero))
                {
                    (lista+k)->numero=arreglo1[i].numero;
                k++;
                lista=realloc(lista,(1+k)*sizeof(struct s_alumno));
                }



        }
        bandera=1;
    }

    /// Proceso Inverso


    for(i=0;i<N;i++)
    {
        for (j=0;j<T;j++)
        {
            if(arreglo2[i].numero==arreglo1[j].numero)
            {
                bandera=0;
            }
        }
            if(bandera==1)
            {
                (lista+k)->numero=arreglo2[i].numero;
                k++;
                lista=realloc(lista,(1+k)*sizeof(struct s_alumno));
            }
            bandera=1;
    }

    (lista+k)->numero=0;
return lista;
}

int esta (t_alumno*lista ,int numero)
{


    int k=0;
    while((lista+k)!=NULL)
    {
        if((lista+k)->numero==numero)
        {
            printf("%d - ",(lista+k)->numero);
            return 1;
        }
        k++;

    }
    return 0;
}


[K-YreX]

No he mirado el resto del programa pero te puedo adelantar que la línea 108 no es correcta. Un array no acaba cuando el siguiente elemento apunta a NULL, básicamente porque no apunta a NULL. Cuando pasas un array debes pasar su longitud en otro parámetro para saber hasta donde recorrerlo.

[palacio29]

No he mirado el resto del programa pero te puedo adelantar que la línea 108 no es correcta. Un array no acaba cuando el siguiente elemento apunta a NULL, básicamente porque no apunta a NULL. Cuando pasas un array debes pasar su longitud en otro parámetro para saber hasta donde recorrerlo.

Muchas gracias, ahi funciono perfecto. Tenes razon, me equivoque y estaba pensando en listas con el puntero al siguiente.



Y si tengo que ordenar un arreglo dinamico y no se la longitud de ese arreglo dinamico...Hasta que punto tengo que recorrerlo?.

[K-YreX]

Y si tengo que ordenar un arreglo dinamico y no se la longitud de ese arreglo dinamico...Hasta que punto tengo que recorrerlo?.

Si creas un arreglo dinámico en algún sitio estás calculando el tamaño que debe tener... guarda esa longitud. En tu caso que vas incrementando en 1 el tamaño con <realloc()>, al final puedes saber también cuál es esa longitud. Mantenla de alguna forma (retorno o referencia). Para ello te recomendaría que la función reciba el nuevo array por referencia y devuelva la longitud de este como valor de retorno:

Código (c) [Seleccionar] Expandir


int CARGA(t_alumno arreglo1[], t_alumno arreglo2[], t_alumno *nuevo_arreglo[]);
El tamaño de la primera dimensión de un array no es necesario pasarlo a la función. También puedes hacerlo al revés:

Código (c) [Seleccionar] Expandir


t_alumno* CARGA(t_alumno arreglo1[], t_alumno arreglo2[], int *longitud_final);