valuesADT, EJ3 2022 RECU 2 CUATRI

[sratto0]

Buenas tardes, queria saber si me podrian ayudar. Me esta fallando la funcion keys, porque en el while dentro de la misma el primer elemento de la lista claves es IMPARES, pero pareciera que no tiene mas elementos(la funcion value no tiene este problema y el ciclo que arme es practicamente analogo)(me falla en el anteultimo assert) Desde ya muchas gracias. adjunto codigo:

#define BLOCK 20

typedef struct node{
    elemType elem;
    struct node *tail;
}TNode;

typedef TNode*TList;

typedef struct keys{
    char *key;
    TList first;
    size_t cant_values;
    struct keys *tail;
}Tkeys;

typedef struct valuesCDT{
    Tkeys* clave;
    size_t cant_claves;
    size_t cant_totalValues;
    struct valuesCDT *tail;
    compare cmp;
}valuesCDT;

valuesADT newValues( compare cmp ){
    valuesADT new=calloc(1, sizeof(valuesCDT));
    new->cmp=cmp;
    return new;
}

long unsigned int sizeKeys(valuesADT v){
    return v->cant_claves;
}

long unsigned int sizeValues(valuesADT v){
    return v->cant_totalValues;
}

static int exists(Tkeys* clave, const char *key){
    if(clave==NULL || strcasecmp(clave->key, key)>0)
        return 0;
    if(strcasecmp(clave->key, key)==0)
        return 1;
    return exists(clave->tail, key);
}

static TList addValue(TList first, elemType elem, compare cmp, int *flag){
    if(first==NULL || cmp(first->elem, elem)>0){
        TList aux=malloc(sizeof(TNode));
        aux->elem=elem;
        aux->tail=first;
        *flag=1;
        return aux;
    }
    if(cmp(first->elem, elem)==0)
        return first;
    first->tail=addValue(first->tail, elem, cmp, flag);
    return first;
}

static char *copy(const char *key){
    char *ans=NULL;
    int i;
    for(i=0;key[i];i++){
        if(i%BLOCK==0)
            ans=realloc(ans, (i+BLOCK)*sizeof(char));
        ans[i]=key[i];
    }
    ans=realloc(ans, (i+1)*sizeof(char));
    ans[i]=0;
    return ans;
}

static Tkeys*addKey(Tkeys*clave, const char *key){
    if(clave==NULL || strcasecmp(clave->key, key)>0){
        Tkeys*aux=malloc(sizeof(Tkeys));
        aux->key=copy(key);
        aux->tail=clave;
        return aux;
    }
    clave->tail=addKey(clave->tail, key);
    return clave;
}

int put(valuesADT v, const char * key, elemType elem){
    int flag=0;
    if(exists(v->clave, key)){
        v->clave->first=addValue(v->clave->first, elem, v->cmp, &flag);
        v->cant_totalValues+=flag;
        v->clave->cant_values+=flag;
        return flag;
    }
    v->clave=addKey(v->clave, key);
    v->cant_claves++;
    v->clave->first=NULL;
    v->clave->cant_values=0;
    v->clave->first=addValue(v->clave->first, elem, v->cmp,&flag);
    v->cant_totalValues+=flag;
    v->clave->cant_values+=flag;
    return flag;
}

elemType * values(valuesADT v, const char * key, long unsigned int * dimValues){
    elemType*vec=NULL;
    if(!exists(v->clave, key)){
        *dimValues=0;
        return vec;
    }
    int j=0;
    while(v->clave!=NULL){
        if(strcasecmp(v->clave->key, key)==0){
            for(int i=0;i<v->clave->cant_values;i++){
                if(j==0)
                    vec=realloc(vec, (v->clave->cant_values)*sizeof(elemType));
                vec[j]=v->clave->first->elem;
                j++;
                v->clave->first=v->clave->first->tail;
            }
        }
        v->clave=v->clave->tail;
    }
    *dimValues=j;
    return vec;
}

char ** keys(valuesADT v){
    char **vec=NULL;
    if(v->cant_claves==0)
        return vec;
    int j=0;
    while(v->clave!=NULL){
        if(j==0)
            vec=realloc(vec, v->cant_claves*sizeof(char *));
        vec[j]=malloc(strlen(v->clave->key)*sizeof(char));
        vec[j++]=copy(v->clave->key);
        v->clave=v->clave->tail;
    }
    return vec;
}

void freeValues(valuesADT v){
    while(v->clave!=NULL){
        while(v->clave->first!=NULL){
            free(v->clave->first->tail);
            v->clave->first=v->clave->first->tail;
        }
        free(v->clave->first);
        free(v->clave->key);
        free(v->clave->tail);
        v->clave=v->clave->tail;
    }
    free(v->clave);
    free(v);
}

int cmpInts(int a, int b) {
return a - b;
}
int main(void) {
valuesADT val = newValues(cmpInts);
assert(sizeKeys(val)==0);
assert(put(val, "pares", 10)==1);
assert(put(val, "Pares", 20)==1);
assert(put(val, "PARES", 10)==0); // Ya estaba el 10 en los pares
assert(put(val, "Pares", 2)==1);
assert(put(val, "Lindos", 10)==1); // el 10 estaba, pero no para esta clave
assert(sizeKeys(val)==2);
assert(sizeValues(val)==4); // 3 en "pares" y uno en "lindos"
size_t dim;
int * pares = values(val, "PaRes", &dim);
assert(dim==3);
assert(pares[0]==2);
assert(pares[1]==10);
assert(pares[2]==20);
free(pares);
put(val, "IMPARES", 13);
char ** vKeys = keys(val);
assert(strcmp(vKeys[0], "IMPARES")==0);
assert(strcmp(vKeys[1], "Lindos")==0);
assert(strcmp(vKeys[2], "pares")==0);
for(int i=0; i < sizeKeys(val);) {
free(vKeys[i]);
}
free(vKeys);
freeValues(val);
return 0;
}

[marcelogarberoglio]

Sumar 1 en vec[j]=malloc(strlen(v->clave->key)*sizeof(char));

¿me parece a mi o esto ya pasó otras veces?

[sratto0]

Si, perdón por molestar y muchas gracias!