Ejercicio práctico de listas enlazadas

Clase 25 de 37 • Curso de Introducción a C 2019

Eduardo Reyes

student•

Siento muy difícil entender cuando Mauro sólo hace el programa y yo no sé realmente qué tenemos que resolver y de una vez hace todo el código cuando a veces los conceptos anteriores no hay quedado tan claros y nos los vuelve a explicar. No hay pasos para crear el código. Es muy confuso.

Ignacio Kuchen

student•

Si me pasa lo mismo me pierdo muchísimo y tengo que reveer los videos.

Brian Ricardo Sanchez Lopez

student•

Que tal, concuerdo en que las clases van algo rápido y pareciera que da por sentado algunos conceptos. Les sugiero el libro "Diseño de algoritmos y su codificación en lenguaje C" no se limiten a la clase, peguenle también a los libros de texto, cuando tuve dudas ahí me puse a leerle. Saludos estimados compañeros.

Victor Muchica Farfan

student•

Agregue printf para validar los valores obtenidos y entender mejor el programa

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

//definir el nodo
typedef struct Node{
    int number; //Lista de numeros
    struct Node * next; //estructura autoreferenciada
}NODE; //en vez de "struct Node" solo pones NODE

//crear funcion que crea un nuevo nodo
NODE * createNode( int number)
{
    NODE * newNode;
    newNode = malloc(sizeof(NODE));
    newNode->next = NULL; //el siguiente del nodo sera NULL
    newNode->number = number; //asignar el dato number al puntero newNode
    return newNode;
}

int main(int argc,const char * argv[]){
    //creando la lista
    NODE * start = NULL,*current; //crea puntero start con NULL para poner la lista vacia
    // current puntero auxiliar

    char goOn; //bandera de continuacion, goOn puede ser int tambien
    int listSize = 0,number; //listSize es el tamaño de la lista
    do{
        printf("La lista tiene %d nodos. Ingrese 0 para terminar\n",listSize);
        scanf("%d",&number);
        if(number){ //si el number es distinto de 0 continua
            if(!start){ //si start = NULL se crea el NODO (lista vacia)
                    start = createNode(number); //crea el nodo start
                    printf("primer nodo start->number %d\n",start->number);
                    printf("primer nodo start->next %p\n",start->next);
               listSize++;
            } else{ //si lista no esta vacia,
                //con el nodo que se acaba de crear, apuntarlo desde el final de la lista
                current = start; //se crea current para no perder el inicio de la lista
                printf("else current->number %d\n",current->number);
                printf("else current->next %p\n",current->next);

                while (current->next){ // mientras current tenga algo en su next
                    printf("while antes current->number %d\n",current->number);
                    printf("while antes current->next %p\n",current->next);
                    printf("current = current->next\n");
                    current = current->next; // current sea igual al siguiente
                    printf("while despues current->number %d\n",current->number);
                    printf("while despues current->next %p\n",current->next);
                    //avanza entre los nodos, termina cuando no tiene siguiente
                }
                //el siguiente sera el nodo que se creara
                current->next=createNode(number); //asi queda encadenado
                printf("Encadena la lista current->number %d\n",current->number);
                printf("Encadena la lista current->next %p\n",current->next);
                listSize++;
            }

            goOn = 1;
        }else{
            goOn = 0;
        }
    }while(goOn); //se detiene si goOn es 0

    current = start; //inicializa el nodo current con el inicio;
    printf("Inicializa current->number %d\n",current->number);
    printf("Inicializa current->next %p\n",current->next);
    printf("La lista tiene los numeros:\n");
    while (current){ //mientras current no sea null
        printf("%d %p",current->number, current->next); //desreferencia current accede a number
        printf(current->next?",":"\n"); //pregunta si existe numero siguiente
        //si es verdadero pone una , y sigue con el siguiente valor sino pone \n
        current = current->next; //para que la repitiva avance
    }

    return 0;
}

Carlos Lefin Henriquez

student•

La verdad es que sin esta sugerencia de usar PRINTF no hubiese podido entender el esquema. muchas gracias por tu aporte. Te mereces un <3

Uzi Jonadab Rodríguez

student•

Solo por este comentario entendí el video jaja

Carlos Nassif Trejo Garcia

student•

#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

// Creando estructura de un nodo
typedef struct Node {
  int number;
  struct Node * next;
} NODE;

// Funcion para llenar un nodo y devolver el puntero
NODE * createNode( int number ) {
  NODE * newNode;
  newNode = malloc( sizeof(NODE) );
  newNode-&gt;next = NULL;
  newNode-&gt;number = number;
  return newNode;
}

int main(int argc, char const *argv[]) {
  // Punteros al linked-list
  NODE * start = NULL, * current;

  // Helpers
  int goOn = 1; //Sigue con el loop
  int listSize = 0, number; // Tamaño de la lista y el buffer

  // Llenar el linked list
  do {
    printf(&quot;La lista contiene %d nodos. Ingrese el siguiente numero (0 para finalizar)\n&quot;, listSize);
    scanf( &quot;%d&quot;, &amp;number );

    // Si el numero es valido
    if ( number ) {
      // Creando no temporal
      NODE * tempNode = createNode( number );

      // Si es el primer nodo, agregarlo al inicio
      if ( !start ) {
        start = tempNode;
      }

      // Ya hay mas nodos, hay que recorrerlos y agregarlo al final
      else {
        current = start;
        while ( current-&gt;next ) {
          current = current-&gt;next;
        }
        current-&gt;next = tempNode;
      }

      listSize++;
    }

    // Si no lo es, salir del loop
    else {
      goOn = 0;
    }
  } while( goOn );

  // Imprimir la lista
  current = start;
  printf(&quot;La lista contiene los numeros: \n&quot;);
  while (current) {
    printf(&quot;%d&quot;, current-&gt;number);
    printf( current-&gt;next ? &quot;, &quot;: &quot;\n&quot; );
    current = current-&gt;next;
  }

  return 0;
}

Javier Nicolás Nieto

student•

El código cumple las mismas funciones que el de Mauro, incluso está optimizado y comentado. Felicitaciones! Solo recuerden agregarle un espacio al final en el return 0;

Daniel Esteban Santos Mendez

student•

Más perdido que la mamá del chavo.

Jordan Ronaldo Buitrago Sandoval

student•

/*Cuando hacemos malloc es bueno hacer un test para saber si es null tal resultado*/
newNode = malloc(sizeof(NODE));
if (newNode == NULL)
	return NULL;

/*awesome trick*/
printf(current->next ? ", " : "\n" );

Allison Peña

student•

En el minuto 5:55 crea un while y Mauro dice: “Mientras current tenga algo en su siguiente” pero analizando el código, vi que en la primera vuelta del ciclo do_while, current es una copia de del nodo start, pero start.next (Y por consiguiente Current.next) no esta inicializada y no debería tener un valor. ahí es cuando me tope con esto: https://es.wikipedia.org/wiki/Variable_no_inicializada

Es por eso que la operación while ( current->next ) si funciona como se espera. para que una variable tenga un valor inicial cero, debemos declararlo explícitamente al definirla.

marco antonio

student•

veo que a muchos se les complico lo de las listas ensaladas ![](

si que hice un codigo lo mas orgánico para que puedan entender como crearlas y destruirlas espero les sirva.

#include <stdio.h>
#include <stdlib.h>
//los defines son como el typedef
//con la diferencia de que pueden renombrar
//cualquier cosa, aqui digo SI es un 0 y NO es un 1
#define SI 0
#define NO 1
typedef struct Nodo Nodo;

struct Nodo{
    int valor;
    Nodo *siguiente;};

int main(void)
{
    //iniciamos poniendo la lista a Nulo
    Nodo *Lista = NULL;
    int valorIngresado,
        salir;
    //creamos un nodo auxliar para su uso posterior
    Nodo *Actual;
    //creamos una variable auxiliar que nos premita
    //saber si la lista esta vacia
    int LalistaEstaVacia = SI;
    printf("ingresa un elemento a la lista\n");
    printf("presiona [0] para salir\n");
    scanf("%d",&valorIngresado);
    salir = valorIngresado;
    //esto se ejecuta a menos que el usuario decida salir
    while(salir){
        //si la lista esta vacia ejecutamos esto
        if(Lista == NULL){
            //hacemos nuestra primer reserva de memoria
            Lista = malloc(sizeof(Nodo));
            //ingresamos el valor del tecleado
            Lista->valor = valorIngresado;
            //hacemos nulo el siguiente nodo
            Lista->siguiente = NULL;
            //indicamos que la lista ya no esta vacia
            LalistaEstaVacia = NO; }
        //si la lista no esta vacia hacemos esto
        else{
            //usaremos un for para recorrer todos los nodos
            //PRIMERO el nodo Actual a la lista
            //SEGUNDO preguntamos si el nodo que le sigue al Actual esta vacio
            //si NO lo esta pasamos a la siguinete instruccion
            //TERCERO Actual toma la direccion del Siguiente nodo
            for(Actual = Lista; Actual->siguiente != NULL; Actual = Actual->siguiente);
            //este for no tiene llaves y lo cerre con ;
            //esto sirve para que haga solo lo que tiene entre parentesis
            //asta que la condicion deje de cumplirse
            //una ves apuntado encontrado el siguiente nodo vacio
            //le almacenamos memoria y despues apuntamos a el
            Actual->siguiente = malloc(sizeof(Nodo));
            Actual = Actual->siguiente;
            //he ingresamos los valores correspondientes
            Actual->valor = valorIngresado;
            Actual->siguiente = NULL;}
        //mandamos a pedir valores del usuario y repetimos denuevo
        // el proseso a menos que el usario decida salir
        printf("ingresa un elemento a la lista\n");
        printf("presiona [0] para salir\n");
        scanf("%d",&valorIngresado);
        salir = valorIngresado;    }

    //PARA IMPRIMIR hacemos un for
    int NumDE_Nodos = 0;
    //esta varaible es los para imprimir el numero del nodo
    //en el que me encuentro realmente no es importante
    for(Actual = Lista; Actual != NULL; Actual = Actual->siguiente){
        ++NumDE_Nodos;
        printf("el %d Nodo contiene %d\n",NumDE_Nodos,Actual->valor);}

    //PARA ELIMINAR LA MEMORIA
    //creamos un Nodo auxiliar que nos de acceso a posiciones de memoria
    //anteriores a las que hiremos destruyendo
    Nodo *Anterior;
    while(LalistaEstaVacia){
        //iniciamos nuestro recorrido desde el puntero actual
        Actual = Lista;
        //hacemos otro while para hacer el recorrido
        //pero antes creamos una variable auxiliar que nos permitira ver
        //si tenemos direcciones previas guardadas para no perderlas al
        //momento de destruiras y asi seguir eliminando los nodos faltantes
        int HayUnaDireccionAnterior = NO;
        //la iniciamos en no por que aun nose a guardado nada
        //tambien declaramos una variable para saver si el
        //ultimo Nodo ha sido eliminado
        int ElultimoNodoSeHaEliminado = NO;
        //una vez que el ultimo nodo se haya elminado empezaremos de cero
        // otras vez asta limpiar por completo la lista
        while(ElultimoNodoSeHaEliminado){
            //preguntamos si el nodo que le sigue al actual esta vacio
            //si es asi llegamos al ultimo elemento por lo que tenemos que
            //eliminar le nodo actual
            if(Actual->siguiente == NULL){
                printf("el valor %d fue eliminado\n",Actual->valor);
                free(Actual);
                //la opcision que tenia nodo Actual se ha perdido
                //para siempre por suerte tenemos la direcion
                //del nodo Anterior
                //pero primero preguntamos si existe una direcion
                //anterior por que de lo contrario significaria que
                //hemos terminado
                if(!HayUnaDireccionAnterior){
                    Anterior->siguiente = NULL;}
                else{
                    LalistaEstaVacia = SI;}
                //la posicion siguiente al anterior era la posicion
                // del nodo Actual
                //es importante poner la posicion que tenia el
                //nodo Actual a NULL ya que si no habra errores
                //indicamos que el ultimo Nodo se ha eliminado
                ElultimoNodoSeHaEliminado = SI;}
            else{
                //apuntamos al nodo Anterior a Actual para que cuando
                //el Nodo Actual apunte al siguiente nodo y este sea eliminado
                //no perdamos la posicion de memoria anterior a esta
                Anterior = Actual;
                Actual = Actual->siguiente;
                //hecho esto significa que tenemos una posiscion anterior
                HayUnaDireccionAnterior = SI;}}}

    //tada ya todo termino
    return 0;
}

Josué Esteban Cordero Ruvalcaba

student•

https://gist.github.com/martincruzot/16f1c181b38743e06449

Aquí hay otra forma en codigo de implementar las listas enlazadas, incluye aparte otras opciones como eliminar nodo, insertar al inicio o al final, entre otras.

Daniel Pastas

student•

Colocar en incremento del tamano de la lista en ambas intrucciones de la condiciones parece redundante. Podria dejarse afuera justo antes de goOn = 1

listSize++;
goON = 1;

Vinicio Velez

student•

me esta haciendo loco :)

Ronald Rengifo

student•

somos 2

Jose Antonio Rojas Ollarves

student•

Otro error: Este programa tiene un error inmenso, por utilizar los ciclos do while, no se especifica que se tienen que colocar datos numericos, si colocas un dato de tipo caracter el bucle se vuelve infinito.

Gerardo Rodriguez Sanchez

student•

Daniel Santos

student•

Este profesor es muy bueno con sus ejemplos pero para entenderle lo mejor es repetir varias veces la clase, realizar el ejemplo y los ejercicios y comentar el código para entender como funciona, LA CLAVE ES LA PRACTICA!

Reinaldo Mendoza

student•

Totalmente de acuerdo, esa es la ventaja de tener el contenido siempre disponible. Sino un par de preguntas en google y ya esta.

Guillermo Castaño Vèlez

student•

Este curso falla en recomendar pre-requisitos....todo empieza muy claro, despacio y luego da un brinco, para programación básica y un curso de introducción, no voy a decir que deja mucho que desear porque para cierto nivel puede que sea muy bueno, pero para los principiantes como yo, que toma la línea de programación básica si faltan algunas clases antes, sobre todo conceptos.

William Andres Dussan Gonzalez

student•

https://www.youtube.com/watch?v=vldM-3PYAmo Este video puede ayudar a bastantes personas a terminar de entender la clase, aunque note que lo entendí

Jeffrey Smith

student•

Gracias William! :) a mí me ayudo más el video anterior del mismo canal: https://www.youtube.com/watch?v=0NzAFk1CwaQ

Victor Muchica Farfan

student•

Tambien sigo a Makigas, tienes dos tutoriales de C muy buenos tambien, pero esta muy bueno el tutorial

Luis Fernando Zarazua Aguilar

student•

La instrucción malloc es un muy parecida a new en orientado a objetos.

Franco Bottazzi

student•

Con orientado a objetos no sé si te referís al uso de new en c++ o en cosas como Javascript, si es el primero si, de hecho new es el reemplazo que se le hizo a malloc (que hace la asignación de memoria más fácil y elegante), en el caso de Javascript no es así, el new en Js está para reemplazar al constructor, porque como las variables pueden tener cualquier tipo de dato, no se usa el constructor abriendo y cerrando paréntesis después del nombre de la variable.

Rafael Arteaga

student•

me perdí en este tema

Luis Mario Amor

student•

somos dos, no se le entiende mucho cuando empieza a escribir codigo, por que no explica nada.

LUIS ALEJANDRO BERNAL ROMERO

student•

¡Faltó liberar la memoria!

Rubén Domínguez Prieto

student•

Entiendo a Daniela Coyotzi cuando explica C, a Mauro no le entiendo

Joel Vicente Nieto Gómez

student•

Que funcion tiene el simbolo "-->" paraeste ejercicio de listas enlazadas?

William Andres Dussan Gonzalez

student•

Es como usarlo en un struct normal, es como el: ApodoStruct.number Tiene la misma funcionalidad solo sirve para asignarle una cosa a los nodos normales, asignarle number o asignarle el next.

Massimo Di Berardino

student•

¡Hola Joel! el símbolo -> en C hace referencia al atributo de un puntero, digamos:

struct Nodo {
  int A;
  int B;
};

struct Nodo *nd = (struct Nodo *)malloc(sizeof(struct Nodo));

// para acceder al atributo de A desde el puntero nd tengo dos opciones 

// opción 1
(*nd).A = 10;

// opción 2
nd->A = 10;

William Andres Dussan Gonzalez

student•

¿En el ciclo Do-While para que sirve el Current->next y que funcionalidad tiene el (->)?

Randy Villanueva Guzmán

student•

El do-while es para recorrer la lista, mientras el apuntador a next no sea null, por lo tanto seguirá entrando en el ciclo. El (- >) es para acceder a los elementos de la estructura, el efecto es igual a usar ( . ) estructura.elemento1, la diferencia es que (- >) se utiliza cuando se declara como apuntador.

NODE start; start.number;

NODE *start; start->number; o (*start).number;

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

//definir el nodo
typedef struct Node{
    int number; //Lista de numeros
    struct Node * next; //estructura autoreferenciada
}NODE; //en vez de "struct Node" solo pones NODE

//crear funcion que crea un nuevo nodo
NODE * createNode( int number)
{
    NODE * newNode;
    newNode = malloc(sizeof(NODE));
    newNode->next = NULL; //el siguiente del nodo sera NULL
    newNode->number = number; //asignar el dato number al puntero newNode
    return newNode;
}

int main(int argc,const char * argv[]){
    //creando la lista
    NODE * start = NULL,*current; //crea puntero start con NULL para poner la lista vacia
    // current puntero auxiliar

    char goOn; //bandera de continuacion, goOn puede ser int tambien
    int listSize = 0,number; //listSize es el tamaño de la lista
    do{
        printf("La lista tiene %d nodos. Ingrese 0 para terminar\n",listSize);
        scanf("%d",&number);
        if(number){ //si el number es distinto de 0 continua
            if(!start){ //si start = NULL se crea el NODO (lista vacia)
                    start = createNode(number); //crea el nodo start
                    printf("primer nodo start->number %d\n",start->number);
                    printf("primer nodo start->next %p\n",start->next);
               listSize++;
            } else{ //si lista no esta vacia,
                //con el nodo que se acaba de crear, apuntarlo desde el final de la lista
                current = start; //se crea current para no perder el inicio de la lista
                printf("else current->number %d\n",current->number);
                printf("else current->next %p\n",current->next);

                while (current->next){ // mientras current tenga algo en su next
                    printf("while antes current->number %d\n",current->number);
                    printf("while antes current->next %p\n",current->next);
                    printf("current = current->next\n");
                    current = current->next; // current sea igual al siguiente
                    printf("while despues current->number %d\n",current->number);
                    printf("while despues current->next %p\n",current->next);
                    //avanza entre los nodos, termina cuando no tiene siguiente
                }
                //el siguiente sera el nodo que se creara
                current->next=createNode(number); //asi queda encadenado
                printf("Encadena la lista current->number %d\n",current->number);
                printf("Encadena la lista current->next %p\n",current->next);
                listSize++;
            }

            goOn = 1;
        }else{
            goOn = 0;
        }
    }while(goOn); //se detiene si goOn es 0

    current = start; //inicializa el nodo current con el inicio;
    printf("Inicializa current->number %d\n",current->number);
    printf("Inicializa current->next %p\n",current->next);
    printf("La lista tiene los numeros:\n");
    while (current){ //mientras current no sea null
        printf("%d %p",current->number, current->next); //desreferencia current accede a number
        printf(current->next?",":"\n"); //pregunta si existe numero siguiente
        //si es verdadero pone una , y sigue con el siguiente valor sino pone \n
        current = current->next; //para que la repitiva avance
    }

    return 0;
}

#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

// Creando estructura de un nodo
typedef struct Node {
  int number;
  struct Node * next;
} NODE;

// Funcion para llenar un nodo y devolver el puntero
NODE * createNode( int number ) {
  NODE * newNode;
  newNode = malloc( sizeof(NODE) );
  newNode-&gt;next = NULL;
  newNode-&gt;number = number;
  return newNode;
}

int main(int argc, char const *argv[]) {
  // Punteros al linked-list
  NODE * start = NULL, * current;

  // Helpers
  int goOn = 1; //Sigue con el loop
  int listSize = 0, number; // Tamaño de la lista y el buffer

  // Llenar el linked list
  do {
    printf(&quot;La lista contiene %d nodos. Ingrese el siguiente numero (0 para finalizar)\n&quot;, listSize);
    scanf( &quot;%d&quot;, &amp;number );

    // Si el numero es valido
    if ( number ) {
      // Creando no temporal
      NODE * tempNode = createNode( number );

      // Si es el primer nodo, agregarlo al inicio
      if ( !start ) {
        start = tempNode;
      }

      // Ya hay mas nodos, hay que recorrerlos y agregarlo al final
      else {
        current = start;
        while ( current-&gt;next ) {
          current = current-&gt;next;
        }
        current-&gt;next = tempNode;
      }

      listSize++;
    }

    // Si no lo es, salir del loop
    else {
      goOn = 0;
    }
  } while( goOn );

  // Imprimir la lista
  current = start;
  printf(&quot;La lista contiene los numeros: \n&quot;);
  while (current) {
    printf(&quot;%d&quot;, current-&gt;number);
    printf( current-&gt;next ? &quot;, &quot;: &quot;\n&quot; );
    current = current-&gt;next;
  }

  return 0;
}

/*Cuando hacemos malloc es bueno hacer un test para saber si es null tal resultado*/
newNode = malloc(sizeof(NODE));
if (newNode == NULL)
	return NULL;

/*awesome trick*/
printf(current->next ? ", " : "\n" );

#include <stdio.h>
#include <stdlib.h>
//los defines son como el typedef
//con la diferencia de que pueden renombrar
//cualquier cosa, aqui digo SI es un 0 y NO es un 1
#define SI 0
#define NO 1
typedef struct Nodo Nodo;

struct Nodo{
    int valor;
    Nodo *siguiente;};

int main(void)
{
    //iniciamos poniendo la lista a Nulo
    Nodo *Lista = NULL;
    int valorIngresado,
        salir;
    //creamos un nodo auxliar para su uso posterior
    Nodo *Actual;
    //creamos una variable auxiliar que nos premita
    //saber si la lista esta vacia
    int LalistaEstaVacia = SI;
    printf("ingresa un elemento a la lista\n");
    printf("presiona [0] para salir\n");
    scanf("%d",&valorIngresado);
    salir = valorIngresado;
    //esto se ejecuta a menos que el usuario decida salir
    while(salir){
        //si la lista esta vacia ejecutamos esto
        if(Lista == NULL){
            //hacemos nuestra primer reserva de memoria
            Lista = malloc(sizeof(Nodo));
            //ingresamos el valor del tecleado
            Lista->valor = valorIngresado;
            //hacemos nulo el siguiente nodo
            Lista->siguiente = NULL;
            //indicamos que la lista ya no esta vacia
            LalistaEstaVacia = NO; }
        //si la lista no esta vacia hacemos esto
        else{
            //usaremos un for para recorrer todos los nodos
            //PRIMERO el nodo Actual a la lista
            //SEGUNDO preguntamos si el nodo que le sigue al Actual esta vacio
            //si NO lo esta pasamos a la siguinete instruccion
            //TERCERO Actual toma la direccion del Siguiente nodo
            for(Actual = Lista; Actual->siguiente != NULL; Actual = Actual->siguiente);
            //este for no tiene llaves y lo cerre con ;
            //esto sirve para que haga solo lo que tiene entre parentesis
            //asta que la condicion deje de cumplirse
            //una ves apuntado encontrado el siguiente nodo vacio
            //le almacenamos memoria y despues apuntamos a el
            Actual->siguiente = malloc(sizeof(Nodo));
            Actual = Actual->siguiente;
            //he ingresamos los valores correspondientes
            Actual->valor = valorIngresado;
            Actual->siguiente = NULL;}
        //mandamos a pedir valores del usuario y repetimos denuevo
        // el proseso a menos que el usario decida salir
        printf("ingresa un elemento a la lista\n");
        printf("presiona [0] para salir\n");
        scanf("%d",&valorIngresado);
        salir = valorIngresado;    }

    //PARA IMPRIMIR hacemos un for
    int NumDE_Nodos = 0;
    //esta varaible es los para imprimir el numero del nodo
    //en el que me encuentro realmente no es importante
    for(Actual = Lista; Actual != NULL; Actual = Actual->siguiente){
        ++NumDE_Nodos;
        printf("el %d Nodo contiene %d\n",NumDE_Nodos,Actual->valor);}

    //PARA ELIMINAR LA MEMORIA
    //creamos un Nodo auxiliar que nos de acceso a posiciones de memoria
    //anteriores a las que hiremos destruyendo
    Nodo *Anterior;
    while(LalistaEstaVacia){
        //iniciamos nuestro recorrido desde el puntero actual
        Actual = Lista;
        //hacemos otro while para hacer el recorrido
        //pero antes creamos una variable auxiliar que nos permitira ver
        //si tenemos direcciones previas guardadas para no perderlas al
        //momento de destruiras y asi seguir eliminando los nodos faltantes
        int HayUnaDireccionAnterior = NO;
        //la iniciamos en no por que aun nose a guardado nada
        //tambien declaramos una variable para saver si el
        //ultimo Nodo ha sido eliminado
        int ElultimoNodoSeHaEliminado = NO;
        //una vez que el ultimo nodo se haya elminado empezaremos de cero
        // otras vez asta limpiar por completo la lista
        while(ElultimoNodoSeHaEliminado){
            //preguntamos si el nodo que le sigue al actual esta vacio
            //si es asi llegamos al ultimo elemento por lo que tenemos que
            //eliminar le nodo actual
            if(Actual->siguiente == NULL){
                printf("el valor %d fue eliminado\n",Actual->valor);
                free(Actual);
                //la opcision que tenia nodo Actual se ha perdido
                //para siempre por suerte tenemos la direcion
                //del nodo Anterior
                //pero primero preguntamos si existe una direcion
                //anterior por que de lo contrario significaria que
                //hemos terminado
                if(!HayUnaDireccionAnterior){
                    Anterior->siguiente = NULL;}
                else{
                    LalistaEstaVacia = SI;}
                //la posicion siguiente al anterior era la posicion
                // del nodo Actual
                //es importante poner la posicion que tenia el
                //nodo Actual a NULL ya que si no habra errores
                //indicamos que el ultimo Nodo se ha eliminado
                ElultimoNodoSeHaEliminado = SI;}
            else{
                //apuntamos al nodo Anterior a Actual para que cuando
                //el Nodo Actual apunte al siguiente nodo y este sea eliminado
                //no perdamos la posicion de memoria anterior a esta
                Anterior = Actual;
                Actual = Actual->siguiente;
                //hecho esto significa que tenemos una posiscion anterior
                HayUnaDireccionAnterior = SI;}}}

    //tada ya todo termino
    return 0;
}

struct Nodo {
  int A;
  int B;
};

struct Nodo *nd = (struct Nodo *)malloc(sizeof(struct Nodo));

// para acceder al atributo de A desde el puntero nd tengo dos opciones 

// opción 1
(*nd).A = 10;

// opción 2
nd->A = 10;

Ejercicio práctico de listas enlazadas

Comprender qué es el lenguaje C

¿Dónde aprender C?

Introducción al curso

Herramientas para programar en C

Aprender los conceptos iniciales del lenguaje C

Compilación y ejecución de un programa en C

Tipos de datos

Definición de variables

Control de flujos

Uso y definición de funciones

Directivas de pre-compilador

Conceptos esenciales

Entender conceptos más profundos del lenguaje C

Punteros

Usos prácticos de los punteros

Aritmética de punteros

Arreglos

Strings

Strings y memoria

Parámetros de línea de comandos

Definición de tipos de datos estructurados

Alias de tipos de datos

Crear bibliotecas propias

Comprender los desafìos de la administración de la memoria

Manejo dinámico de la memoria

Cómo instalar Valgrind

Memory leaks y Garbage Collectors

Listas enlazadas

Ejercicio práctico de listas enlazadas

Liberando las listas enlazadas

Reto: Modifica el programa para que permita eliminar los nodos en los que se encuentre un determinado número

Usos prácticos

Cálculos complejos

Manejo de archivos de texto

Manejo de archivos binarios

Paralelismo

Comunicación entre procesos

Pipes

Sockets

Sockets: Código del servidor

Sockets: código de cliente

Comunicación vía sockets: ejecución

Conclusiones

Conclusiones