Listas enlazadas

[Leber]

Buenas, tengo una duda con las listas enlazadas, me he leido varias webs donde hablan de ellas, y mas o menos tengo el concepto, pero tengo algunas dudas, las discutire sobre un ejemplo(no es mio el ejemplo, solo la funcion nombres)

Código:

struct lista
{
   char *nombre;
   int clave;
   struct lista *sig;
};


char *nombres(int n)  /*esto lo inserte yo para a ver si lo habia entendido*/
{

char *nombre[]={"Hola","Adios","Que tal","Pepe"};

 return nombre[n];

}

int
main()
{

struct lista *L;
struct lista *p;
int i;

L=NULL;



  for(i=0;i<4;i++)
   {
    p=(struct lista *)malloc(sizeof(struct lista));
    p->nombre=nombres(i);
    p->clave=i;
    p->sig=L;
    L=p;
   }

    while(p!=NULL)
    {
     
     printf("\tp->nombre=%s\tp->clave = %d\n",p->nombre,p->clave);
     p=p->sig;
    }

Vayamos por partes:

Código:

struct lista
{
   char *nombre;
   int clave;
   struct lista *sig;
};

Una estructura con un apuntador a caracter, un entero, y un apuntador a la misma estructura. Corrijanme si me equivoco.

Siguiente:

Código:

int
main()
{

struct lista *L;
struct lista *p;
int i;

L=NULL;

Definimos una varible auxiliar "p", que sera la encargada de crear mas nodos, y creamos la lista vacia con L=NULL;

Siguiente:

Código:

for(i=0;i<4;i++)
   {
    p=(struct lista *)malloc(sizeof(struct lista));
    p->nombre=nombres(i);
    p->clave=i;
    p->sig=L;
    L=p;
   }

Con la variable p creamos 4 nodos: 0,1,2,3.

Le asignamos el nombre, y la clave, y hacemos que la estructura siguiente sea NULL, es decir, vacia(p->sig=L, como L es NULL)

Y lo que no entiendo es que hace:

Código:

 L=p;

L apunta a NULL otra vez?

Y esto tambien me descoloca:

Código:

while(p!=NULL)
    {
     
     printf("\tp->nombre=%s\tp->clave = %d\n",p->nombre,p->clave);
     p=p->sig;
    }

Mientras la siguiente estructura no sea vacia, mostramos nombre y clave, pero lo que me descoloca un poco, esque va para atras, y cuando hemos creado los nodos, el que estaba vacio era el siguiente del que habiamos creado, pero aqui buscamos para atras, es decir, buscamos si el anterior esta vacio¿no? Eso no me acaba de cuadrar.

Es lo unico que no acabo de entender, por lo demas, llevo miradas varias y mas o menos entiendo el concepto. Si alguien fuera tan amable de explicarmelo, se lo agradeceria.

Muchas gracias de antemano, saludos

[Mephisto]

Vayamos por partes:


Código: struct lista
{
char *nombre;
int clave;
struct lista *sig;
};
Una estructura con un apuntador a caracter, un entero, y un apuntador a la misma estructura. Corrijanme si me equivoco.

Es un apuntador a una estructura del mismo tipo, no a ella misma, si se quiere que apunte a si misma eso se haría después aunque no tendría mucho sentido.

main()
{

struct lista *L;
struct lista *p;
int i;

L=NULL;
Definimos una varible auxiliar "p", que sera la encargada de crear mas nodos, y creamos la lista vacia con L=NULL;

Recuerda que L y p son apuntadores a un tipo en especifico, aqui ambos son apuntadores a una estructura de tipo lista, p aun no han sido referenciada y L se referencia a nulo.

for(i=0;i<4;i++)
{
p=(struct lista *)malloc(sizeof(struct lista));
p->nombre=nombres(i);
p->clave=i;
p->sig=L;
L=p;
}

Genera el nodo, y sí, la primera vez L es NULL por lo que en el primer nodo el apuntador al siguiente nodo es nulo. Esta situacion cambia en la segunda iteración ya que L ya tiene un valor, por lo que se genera un nuevo nodo y el apuntador al siguiente nodo lo mandas a L y despúes lo mandas al inicio de la lista. Con esto L apuntará al primer nodo de la lista.

Lo unico es que el llenado de esta lista es como una pila (LIFO)

Espero poder ponerlo claro. Considerando que ◙ son los nodos creados

Código:

                  Incio del prog
                  p  undefined
                  L NULL
 
                  1a iteraciòn
                   Al crear el nodo tenemos
                   p->◙
                   L ->NULL             

                  Al ejecutar     
                  p->sig=L;

                  p->◙->NULL

                  Al ejecutar     
                  L=p;       
          
                  L->◙->NULL
                  
                  2a iteraciòn
                   Al crear el nodo tenemos
                   p->◙
                   L ->◙->NULL             

                  Al ejecutar     
                  p->sig=L;

                  p->◙->L->◙->NULL

                  Al ejecutar     
                  L=p;       
          
                  L->◙->◙->NULL


                  3a iteraciòn
                   Al crear el nodo tenemos
                   p->◙
                   L ->◙->◙->NULL             

                  Al ejecutar     
                  p->sig=L;

                  p->◙->L->◙->◙->NULL

                  Al ejecutar     
                  L=p;       
          
                  L->◙->◙->◙->NULL

Espero haber sido claro...