[C/C++]: Valori sovrascritti in lista nodi collegati

[Rik142]

Ciao a tutti!!
Sto programmando in c++ ed ho il seguente problema.
In seguito ad aver fatto una lettura da file, file in cui i dati sono suddivisi in tre parti, devo inserire i dati stessi sempre nella stessa cella, quindi una volta creata la devo riutilizzare senza che i dati vengano persi di volta in volta.
La struttura che utilizzo è la seguente:

struct nodo
{
double x;
double y;
int numVerticiCollegati;
struct nodoCollegato *elencoVerticiCollegati;
};

struct nodoCollegato
{
int vertice;
float peso;
struct nodoCollegato *next;
};

Chi mi sa dare una mano??

Grazie!!

Rik142

[fastcoder]

Sinceramente non ho capito il problema la struttura dati mi sembra OK (forse più adatta ad un programma c che non c++)....se non aggiungi qualche chiarimento credo sia un po' dura capire il tuo problema.
Se riutilizzi la cella credo che i dati precedenti (nella stessa cella) li perdi per forza...a meno che sia questo il tuo problema.
Non protresti scrivere anche quello che vuoi fare in maniera più formale ?

[Rik142]

Allora:
il problema principale è proprio quello che perdo i dati precedentemente inseriti ogni volta che vado a fare un inserimento di un nuovo dato.
Esempio:

8 //blocco uno
0 0.144195 0.602996
1 0.513109 0.788390
2 0.297753 0.357678
3 0.149813 0.895131
4 0.451311 0.550562
5 0.874532 0.848315
6 0.747191 0.664794
7 0.859551 0.483146

0 4 1 2 3 4 //blocco 2
1 5 0 4 3 5 6
2 2 0 4
3 2 0 1
4 5 2 1 0 6 7
5 3 6 1 7
6 4 5 1 4 7
7 3 6 5 4

0 4 0.412 0.289 0.292 0.311 //blocco tre
1 5 0.412 0.245 0.704 0.366 0.264
2 2 0.289 0.246
3 2 0.292 0.704
4 5 0.246 0.245 0.311 0.317 1.473
5 3 0.223 0.366 0.365
6 4 0.223 0.264 0.317 0.213
7 3 0.213 0.365 1.473

dopo aver inserito i valori di x ed y del blocco uno, devo inserire i valori del blocco due a parità di indice di cella: nella cella 0 oltre alle coordinate 0.144195 0.602996 ci andranno in un numero di celle pari a 4 i numeri 1,2,3,4; ecc... così per tutte le celle.
Quando passo al blocco due e/o blocco tre e richiamo la cella in questione i dati precedentemente inseriti non ci sono più.
Spero di essere stato chiaro.

[fastcoder]

Credo di aver capito...la struttura potrebbe anche andar bene (io avrei usato una classe ma è lo stesso) per lo scopo, quindi il problema è nel modo in cui la usi.
Senza codice direi che il problema sta nella gestione della lista nodi collegati, non è che puoi estrarre tale parte dal tuo codice e postarla ?



PS: credo di aver capito che il blocco tre va a definire i pesi dei vertici collegati, il blocco 2 invece indica i vertici collegati.

PS: per i vertici collegati (dato che il numero lo conosci prima di leggerli) avrei usato un array invece che una lista per risparmiare il puntatore al successivo; ovviamente se il numero non varia nel tempo...

[Rik142]

Esatto!!!!
Inoltre ti segnalo, visto che ho inserito il codice, che nella funzione leggi_vertici non viene passato il valore aux->elencoVerticiCollegati->vertice e in fase di esecuzione il programma termina. Sbaglio con l'assegnamento?

Grazie mille!!!

struct nodo
{
double x;
double y;
int numVerticiCollegati;
struct nodoCollegato *elencoVerticiCollegati;
};

struct nodoCollegato
{
int vertice;
float peso;
struct nodoCollegato *next;
};

struct nodo G[MAX];

int leggi_grafo()
{
int i, n, valorecorrente;

fdata = fopen("9.txt","r");
fw = fopen("risultato.txt","w");
fscanf(fdata,"%d ",&n);
printf("Numero di vertici: %d\n", n);

fscanf(fdata,"%d ",&valorecorrente);
for (i = 0; i<n; i++)
{
valorecorrente = coordinate(&G[i], valorecorrente);
}
printf("\n");
for(i=0; i<n; i++)
{
valorecorrente = leggi_vertici(&G[i], valorecorrente);
}
printf("\n");
for(i=0; i<n; i++)
{
valorecorrente = archi(&G[i], valorecorrente);
}
ecc...

int coordinate(struct nodo **testa, int primovalore)
{
struct nodo *nuovo;
int valorecorrente;
double x;
double y;

*testa = NULL;
valorecorrente = primovalore;
while (!feof(fdata) && primovalore == valorecorrente)
{
fscanf(fdata,"%lf %lf", &x, &y);
nuovo = (struct nodo *) malloc (sizeof(struct nodo));
nuovo->x = x;
nuovo->y = y;
*testa = nuovo;
printf("\n%lf %lf", (*testa)->x, (*testa)->y);
fscanf(fdata,"%d",&valorecorrente);
}
return valorecorrente;
}

int leggi_vertici(struct nodo **testa, int primovalore)
{
struct nodo *aux;
int num_totali = 0, var = 0, valorecorrente, i = 0;

*testa = NULL;
valorecorrente = primovalore;
while (!feof(fdata) && primovalore == valorecorrente )
{
fscanf(fdata,"%d", &num_totali);
while ( i != num_totali )
{
fscanf(fdata,"%d",&var);
aux = (struct nodo *) malloc (sizeof(struct nodo));
aux->numVerticiCollegati = num_totali;
printf("\nNum_vertici: %d",aux->numVerticiCollegati);
aux->elencoVerticiCollegati->vertice = var;
*testa = aux;
printf("\nSTAMPA: %d %d", (*testa)->numVerticiCollegati, ((*testa)->elencoVerticiCollegati)->vertice);
i++;
}
fscanf(fdata,"%d",&valorecorrente);
}
return valorecorrente;
}

[fastcoder]

OK...forse sbaglio ma non capisco come faccia a compilare....se poi compila direi che
avresti qualche problema in esecuzione
coordinate la scriverei così e la metterei prima di leggi_grafo (così ti accorgi che in effetti
ci vuole il puntatore semplice e non il doppio):

int coordinate(struct nodo *testa, int primovalore) // quà non passi un array di puntatori ma un array di strutture
{
struct nodo *nuovo;
int valorecorrente;
double x;
double y;

// *testa = NULL; non va proprio bene questo.
valorecorrente = primovalore;
while (!feof(fdata) && primovalore == valorecorrente)
{
fscanf(fdata,"%lf %lf", &x, &y);
//nuovo = (struct nodo *) malloc (sizeof(struct nodo)); non devi allocare memoria...ci hai già pensato quando hai creato l'array.
//nuovo->x = x;
//nuovo->y = y;
//*testa = nuovo;
testa->x = x;
testa->y = y;
testa->elencoVerticiCollegati = NULL; // E' meglio che la inizializzi la lista...
printf("\n%lf %lf", (*testa)->x, (*testa)->y);
fscanf(fdata,"%d",&valorecorrente);
testa++; // Vai al valore successivo dell'array
}
return valorecorrente;
}

leggi_vertici invece temo che la devi proprio riscrivere....dubito che possa mai funzionare.
Qualche hint:
- leggi_vertici dovrebbe vedere (per ogni nodo) se la lista dei vertici collegati è già stata creata (controllando se elencoVerticiCollegati è NULL) se non lo è allora la dovrà creare con qualcosa del tipo #elencoVerticiCollegati = malloc(....)#, altrimenti scorrerà tale lista ed imposterà il numero del vertice collegato (se leggo record 2) oppure il peso se (leggo record 3); ovviamente dovrai dire alla funzione (che non ne sa nulla) se sta leggendo il record 2 o il record 3.

Temo che devi studiarti un po' meglio la struttura dati e l'uso delle liste linkate
perchè per me (ma posso sbagliare) quello che hai scritto difficilmente funzionerà.

Buon lavoro

[fastcoder]

Aggiundendomi a quello che ti ho detto ecco quello che farei (ho usato un'array invece che
una lista linkata perchè in questo caso credo sia meglio, quindi non uso next in alcun modo):

int leggi_vertici(struct nodo *testa, int primovalore, int n_record)
{
  nodoCollegato *tmp_clg = NULL;
  int num_totali = 0, var = 0, valorecorrente, i = 0;

  valorecorrente = primovalore;
  while (!feof(fdata) && primovalore == valorecorrente )
  {
    fscanf(fdata,"%d", &num_totali);
    testa->numVerticiCollegati = num_totali; 
    if( !testa->elencoVerticiCollegati )
    {
      tmp_clg = new nodoCollegato[num_totali];
      testa->elencoVerticiCollegati = tmp_clg;
    }
    else
      tmp_clg = testa->elencoVerticiCollegati;
    for( i = 0; i < num_totali; i++ )
    {
       fscanf(fdata,"%d",&var);
       if( n_record == 2 )
         tmp_clg[i]->vertice = var;
       else
         tmp_clg[i]->peso = var;
    }
    fscanf(fdata,"%d",&valorecorrente);
    testa++;
  }
  return valorecorrente;
}

Non so se va...io sinceramente avrei usato delle classi e lo avrei scritto diversamente....ma magari questo ti da una idea...


Dimenticavo...ovviamente la memoria allocata la devi liberare con una bella delete [] quando hai finito (ed una bella classe con distruttore ti semplicava la vita)

[Rik142]

Ti ringrazio per i continui consigli che mi stai dando.
Guardando l'ultimo suggerimento non capisco alcune cose:

1) cosa indica n_record nella dichiarazione della funzione
2) non capisco la parte finale. Più precisamente:

if( n_record == 2 )
temp[i]->vertice = var;
else
temp[i]->peso = var;

Il peso di ogni arco lo devo inserire solo quando ho finito di analizzare il secondo blocco e per ogni vertice rifaccio lo stesso gioco eseguito poco prima con i vertici collegati in virtù del fatto che ho una terza chiamata a funzione nominata int archi che per ogni vertice inserisce il peso di ogni arco da vertice "a" a vertice "b".



Purtroppo le classi non le so usare e implementando il codice pensavo fosse molto più semplice così.

[fastcoder]

n_record l'ho usato per poter capire cosa sto leggendo (il numero del vertice o il peso)...se ho ben capito prima leggo i vertici (record tipo 2) e poi i pesi (record tipo 3); siccome uso sempre la stessa funzione devo capire cosa sto leggendo; n_record è 2 la prima volta, 3 la seconda.
Siccome parli di una terza funzione (che non ho visto)...n_record non serve a nulla

Lo so che l'uso delle classi è un poco ostico da principio...ma ti posso assicurare che alla lunga vieni ripagato...ho sempre trovato che pensare Object Oriented è un buon modo per analizzare e risolvere i problemi...ma in fondo è un modo come un'altro

[Rik142]

Non mi accetta la ridefinizione di temp con new!!
Se lo inizializzo direttamente alla capacità massima userei troppa memoria inutilmente visto che il numero di celle a me utili è decisamente inferiore al numero dei nodi?