[C] problema con programmino banale in C

[biondina]

Ciao a tutti.
Ho un problema banale ma che non riesco proprio a risolvere.
L'esercio mi chiede:

" Il programma ha una lista collegata con puntatori, ordinata in senso crescente.
Devo scrivere la funzione che incrementa ordinatamente di 1 gli elementi della lista fino a ritrovare un elemento il cui valore incrementato è
maggiore di una soglia data in ingresso. Gli elementi a partire dal primo che supera la soglia fino all'ultimo devono essere cancellati liberando la memoria. La funzione deve restituire come valore di ritorno il numero di elementi cancellati"

Il mio problema è che se ad esempio inserisco la lista 2 4 6 8 10 12 e come soglia inserisco valore 8 (presente nella lista) mi ritorna il numero di cancellazioni è 3 che è giusto; ma se inserisco valore 7 (che non c'è nella lista) mi ritorna un valore tipo 229134. Perchè?

Sotto riporto il programma

#include <stdio.h>

#include <stdlib.h>

#include <memory.h>

struct list {

int value;

struct list * next_ptr;

};

void init( struct list ** ptrptr );

void visit( struct list * ptr );

void pre_insert( struct list ** ptrptr, int value );

void ord_insert(struct list ** ptrptr, int value);

int camb_list(struct list*ptrptr,int thres);

int delete_list_el (struct list**ptrptr);

void init( struct list ** ptrptr ){

*ptrptr = NULL;

}

void visit( struct list * ptr )

/* visita della lista*/

{

while ( ptr != NULL ) {

printf( "%d ", ptr->value );

ptr = ptr->next_ptr;

}

}

void pre_insert( struct list ** ptrptr, int value )

/* inserisce in testa*/

{

struct list * tmp_ptr;

tmp_ptr = *ptrptr;

*ptrptr = (struct list *) malloc( sizeof(struct list));

(*ptrptr)->value = value;

(*ptrptr)->next_ptr = tmp_ptr;

}

void ord_insert(struct list ** ptrptr, int value)

/* inserisce in ordine*/

{ while(*ptrptr!=NULL && (*ptrptr)->value<value)

{ptrptr=&((*ptrptr)->next_ptr);

}

pre_insert(ptrptr,value);

}

int camb_list (struct list*ptrptr,int thres)

/*incrementa valori della lista per 1, fino a trovare uno >= di soglia. se trova un elemento > lo cancella dalla lista */

{ int num_canch;

while (ptrptr!=NULL && (ptrptr)->value<=thres)

{ (ptrptr)->value=(ptrptr)->value+1;

if ((ptrptr)->value>=thres){

num_canch=delete_list_el(&ptrptr);

}

else

ptrptr=(ptrptr)->next_ptr;

}

return num_canch;

}

[Daniels118]

Dov'è la funzione delete_list_el?

[biondina]

Originariamente inviato da Daniels118

Dov'è la funzione delete_list_el?

non mi ha inserito tutto. ecco il resto:

int delete_list_el(struct list**ptrptr)
/*cancellazione*/
{
struct list*tmp;
int num_canch;
num_canch=0;
while(*ptrptr!=NULL){
tmp=*ptrptr;
*ptrptr=(*ptrptr)->next_ptr;
num_canch++;
free(tmp);
}
return num_canch;
}



int main (){

int value;
int thres;
int i;
int cancellati;
cancellati =0;
int e;
e=1;
struct list *list_ptr;
init( &list_ptr );

while (e==1){

printf( "\nInserisci valori della lista:\n");
for(i=0;i<10; i++){
scanf( "%d", &value );
ord_insert( &list_ptr, value);
}

printf( "\n\nLista inserita: " );
visit( list_ptr );

printf("\n\nInserisci numero di soglia: ");
scanf("%d",&thres);

cancellati=camb_list(list_ptr,thres);

printf("\n\nNumero di elementi cancellati: ");
printf("%d",cancellati);

printf("\n\nSe vuoi finire il programma premi il tasto 0 ");
scanf("%d",&e);

}

}

[sottovento]

int camb_list (struct list*ptrptr,int thres) /*incrementa valori della lista per 1, fino a trovare uno >= di soglia. se trova un elemento > lo cancella dalla lista */
{
    int num_canch;
    while (ptrptr!=NULL && (ptrptr)->value<=thres)
    {
        (ptrptr)->value=(ptrptr)->value+1;
        if ((ptrptr)->value>=thres)
        {
            num_canch=delete_list_el(&ptrptr);
            // Ora ptrptr non e' piu' valido!!! Dovresti mettere chi lo punta a NULL, e mettere ptrptr a NULL
        }
        else
            ptrptr=(ptrptr)->next_ptr;
    }

    return num_canch;
}

[Daniels118]

@sottovento
Non è così: delete_list_el prende il puntatore a ptrptr e aggiorna ptrptr dopo aver cancellato l'elemento a cui punta.

@biondina
Sebbene la logica della cancellazione sia un po' contorta, non vedo alcun errore, il programma funziona correttamente con i dati di input che hai indicato.

[biondina]

[quote=Daniels118;40614963]@sottovento

ma perche allora se come soglia inserisco un valore che non presente in lista inserita, il valore di ritono mi da un numero enorme tipo 22934 se deve ritornare ad esempio 3 ?

[sottovento]

Originariamente inviato da Daniels118

@sottovento
Non è così: delete_list_el prende il puntatore a ptrptr e aggiorna ptrptr dopo aver cancellato l'elemento a cui punta.

Si, avevo visto male, il problema e' in num_canch:

int camb_list (struct list*ptrptr,int thres) /*incrementa valori della lista per 1, fino a trovare uno >= di soglia. se trova un elemento > lo cancella dalla lista */
{
    int num_canch;
    while (ptrptr!=NULL && (ptrptr)->value<=thres)
    {
        (ptrptr)->value=(ptrptr)->value+1;
        if ((ptrptr)->value>=thres)
        {
            num_canch=delete_list_el(&ptrptr);
        }
        else
            ptrptr=(ptrptr)->next_ptr;
    }

    return num_canch;
}

In pratica, se tutti i valori che hai inserito sono maggiori della soglia, allora ottieni risultati a capocchia

[Daniels118]

A me il programma funziona senza problemi:

[biondina]

In pratica, se tutti i valori che hai inserito sono maggiori della soglia, allora ottieni risultati a capocchia[/quote]

ho provato a fare cosi:
int camb_list (struct list*ptrptr,int thres) {
int num_canch;
num_canch=0;
while (ptrptr!=NULL)
{ (ptrptr)->value=(ptrptr)->value+1;
if ((ptrptr)->value>=thres){
delete_list_el(&ptrptr);
num_canch++;
ptrptr=(ptrptr)->next_ptr;
}
else
ptrptr=(ptrptr)->next_ptr;
}
return num_canch;
}

void delete_list_el(struct list**ptrptr){
struct list*tmp;
tmp=*ptrptr;
*ptrptr=(*ptrptr)->next_ptr;
free(tmp);


Sembra meglio, ma cmq mi torna il valore un po sbagliato. ad esempio se deve restituire 4 mi restituische 2, se 10 torna 5 ecc.
cosa devo cambiare?
P.S. io non sono italiana quindi mi potresti spiegare in modo piu semplice

[biondina]

Originariamente inviato da Daniels118

A me il programma funziona senza problemi:

MA COME MAI!!???

a me no funziona

[Daniels118]

Ah, scusa, non avevo visto l'ultima nota.

[sottovento]

Originariamente inviato da Daniels118

A me il programma funziona senza problemi:

Prova ad inserire gli stessi numeri di prima, ma 1 come soglia

[sottovento]

Originariamente inviato da biondina

MA COME MAI!!???

a me no funziona

L'esempio che hai pubblicato mi sembra corretto: prima incrementi e poi controlli che il valore sia >= della soglia. Quindi il 6 diventa 7 e rientra nell'insieme degli elementi da cancellare.
Hai un altro esempio?

EDIT - ops, sono sbadato:

int camb_list (struct list*ptrptr,int thres)
{
    int num_canch;
    num_canch=0;
    while (ptrptr!=NULL)
    {
        (ptrptr)->value=(ptrptr)->value+1;
        if ((ptrptr)->value>=thres)
        {
            delete_list_el(&ptrptr);   // OK - Questa cancella l'elemento corrente, e l'elemento successivo diventa corrente
            num_canch++;  // OK - incrementi il tuo contatore
            ptrptr=(ptrptr)->next_ptr;  // NO! Salti l'elemento successivo che e' diventato corrente! Non mi piace per niente!!!!
        }
        else
            ptrptr=(ptrptr)->next_ptr;
    }
    return num_canch;
}

[biondina]

Originariamente inviato da sottovento

Hai un altro esempio?

Se faccio in questo modo:


int camb_list (struct list*ptrptr,int thres) {
int num_canch;
num_canch=0;
while (ptrptr!=NULL)
{ (ptrptr)->value=(ptrptr)->value+1;
if ((ptrptr)->value>=thres){
delete_list_el(&ptrptr);
num_canch++;
ptrptr=(ptrptr)->next_ptr;
}
else
ptrptr=(ptrptr)->next_ptr;
}
return num_canch;
}

void delete_list_el(struct list**ptrptr){
struct list*tmp;
tmp=*ptrptr;
*ptrptr=(*ptrptr)->next_ptr;
free(tmp);


mi fa:

lista inserita: 2 4 6 8 10 12
soglia 7
numero di el cancellati 2

invece deve essere 4

[sottovento]

Scusa, ho fatto un edit al post precedente, probabilmente mentre scrivevi. Non lo ricopio qui per ovvii motivi, prova a rileggerlo ora.

[biondina]

Originariamente inviato da sottovento

EDIT - ops, sono sbadato:

int camb_list (struct list*ptrptr,int thres)
{
    int num_canch;
    num_canch=0;
    while (ptrptr!=NULL)
    {
        (ptrptr)->value=(ptrptr)->value+1;
        if ((ptrptr)->value>=thres)
        {
            delete_list_el(&ptrptr);   // OK - Questa cancella l'elemento corrente, e l'elemento successivo diventa corrente
            num_canch++;  // OK - incrementi il tuo contatore
            ptrptr=(ptrptr)->next_ptr;  // NO! Salti l'elemento successivo che e' diventato corrente! Non mi piace per niente!!!!
        }
        else
            ptrptr=(ptrptr)->next_ptr;
    }
    return num_canch;
}

SIIII!!!! Ora funziona!!
Grazie mille!

[mb1559]

Originariamente inviato da biondina

SIIII!!!! Ora funziona!!
Grazie mille!

Potresti inviarmi il programma completo? Le modifiche suggerite non mi funzionano:confused. Dove sbaglio?

[sottovento]

Originariamente inviato da mb1559

Potresti inviarmi il programma completo? Le modifiche suggerite non mi funzionano:confused. Dove sbaglio?

Scusa il ritardo

[mb1559]

Originariamente inviato da sottovento

Scusa il ritardo

Ti ringrazio della risposta, ma nel file "test" non c'è il programma o le indicazioni per eliminare errore! Ti risulta sia così o devo prendere atto che il c non è cosa per me?

ciao grazie