[C] Inizializzare lista

[xbubbax]

Allora, ho studiato le liste, ho capito come si fanno le operazioni su di essa ma non so come si dichiara, nel senso come si inseriscono i valori nei vari nodi.

ho provato a scrivere questo, ad esempio se voglio inizializzare i primi 3 nodi con gli elementi 27 7 87 come si fa? mi serve la procedura piu semplice, giusto per capire il meccanismo

#include <stdio.h>
struct nodo{
       int data;
       struct nodo* ptr;}:
int main(){
           
           typedef struct nodo NODO;
           typedef struct nodo* NODOptr;

[xbubbax]

ad esempio ho scritto questo programmino per stampare una lista, ma mi manca il pezzo dove inserisco gli elementi della lista, ora provo a scrivero io ma non penso di riuscirci

#include <stdio.h>
struct nodo{
       int data;
       struct nodo* ptr;}:
int main(){
           
           typedef struct nodo NODO;
           typedef struct nodo* NODOptr;
           
           
           


void stampalista(NODOptr L1){
     
     if(L1!=NULL){
                  printf("->%d", L1->elem);
                  stampalista(L1->next);}
                  else printf("->NULL");}

[andbin]

#include <stdio.h>
#include <stdlib.h>

typedef struct nodo
{
    int data;
    struct nodo *next;
} NODO, *PNODO, **PPNODO;

int List_Append (PPNODO pproot, int data)
{
    PNODO pnodo;

    if (pproot == NULL)
        return 0;

    if ((pnodo = (PNODO) malloc (sizeof (NODO))) == NULL)
        return 0;

    pnodo->data = data;
    pnodo->next = NULL;

    while (*pproot != NULL)
        pproot = &(*pproot)->next;
    
    *pproot = pnodo;
    return 1;
}

int main (void)
{
    PNODO proot = NULL;

    List_Append (&proot, 27);
    List_Append (&proot, 7);
    List_Append (&proot, 87);

    return 0;
}

Nota: per brevità nel main non ho testato il valore di ritorno di List_Append.

[xbubbax]

mi stai facendo impazzire andbin

non c'è un modo piu semplice? magari lasciando il mio programma così com'è e aggiungendo solo il necessario per le dichiarazioni?

[andbin]

Originariamente inviato da xbubbax

non c'è un modo piu semplice? magari lasciando il mio programma così com'è e aggiungendo solo il necessario per le dichiarazioni?

Più semplice??

Più semplice di così si muore!! C'è da fare sostanzialmente 4 cose: allocare la nuova struttura, inizializzarla, cercare il fondo della lista e accodare il nodo.

Nel mio codice ho solo messo dei nomi di mio gradimento ma il succo è quello. Anzi il mio codice è sicuramente pulito e lineare. Cerca di capire cosa fa List_Append e avrai capito come si aggiunge un nodo.

[xbubbax]

si infatti devo leggerla bene, ora intanto sto imparando a fare le funzioni sulle liste, tipo ricerca di un elemento, somma degli elementi ecc... e poi cerco di capire come si inizializzano

[Baronerosso9]

Allora...la lista che vuoi creare te mi sembra di capire che sia una lista in forma collegata con puntatori.
Allora devi, prima dichiarare nel main una variabile di tipo puntatore a lista(è il buffer dove terrai memorizzato il primo valore della lista). Poi inizializzi la lista ( cioè il puntatore lo imposti uguale a NULL). (per inizializzare una variabile da un'altra funzione devi passare il puntatore a tale variabile, quindi in questo caso devi passare un doppio puntatore). dopo aver inizializzato...inserisci come sta scritto nel mio codice:

struct list
{
float value;
struct list * nextptr;
};

void init(struct list ** ptrptr) //inizializzazione
{
*ptrptr=NULL;
}

void preinsert(struct list ** ptrptr, float value) //inserimento in testa
{
struct list * tmpptr;
tmpptr=*ptrptr;
*ptrptr=(struct list *)malloc(sizeof(struct list));
(*ptrptr)->nextptr=tmpptr;
(*ptrptr)->value=value;
}

void sufinsert(struct list **ptrptr, float value) //inserimento in coda
{
while (*ptrptr!=NULL)
ptrptr=&((*ptrptr)->nextptr);
preinsert(ptrptr,value);
}


int main(int argc, char *argv[])
{
struct list * ptr;
float valore;
init(&ptr);
.
.
.
preinsert(&ptr,valore);
.
.
.
sufinsert(&ptr,valore);
return 0;
}

Spero sia tutto chiaro...cerca sempre di dividere un problema insormontabile in tanti problemini facili (funzioni).
A presto