Liberando las listas enlazadas

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

José osvaldo de la cruz caceres

student•

estoy aprendiendo mas con un pdf que encontre en internet que con estas explicaciones, se esta escribiendo codigo sin explicar el porque de las cosas personalmente pienso que este curso no nos lleva a donde queremos a menos que se busque una explicacion en otras fuentes, muy mal curso

Ronald Rengifo

student•

puedes compartir ese pdf ?

José osvaldo de la cruz caceres

student•

Algoritmos a fondo Con implementaciones en C y Java Ing. Pablo Augusto Sznajdleder

Victor Muchica Farfan

student•

En el código agrego los printf para que sea mas visual los cambios de asignación y sea mas entendible.

Para personas que se inician en programación creo sera mas entendible. pueden variar el código y hacer sus propios cambios si asi lo desean.

#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, *sig; //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
    }

    //liberar memoria
    current = start;
    printf("\nLiberar memoria\n");
    while (current->next!= NULL){ //mientras current no sea null
        printf("\ndireccion current next: %p\n",current->next);
        printf("direccion current number: %d\n",current->number);
        sig = current->next; //quedarnos con el nodo
        printf("Asigna current->next a sig\n");
        printf("direccion sig next: %p\n",sig->next);
        printf("direccion sig number: %d\n",sig->number);
        free(current); //libera el nodo actual
        printf("Libera current\n");
        current = sig; //current sera sig
        printf("Asigna sig a current\n");
        printf("valor current->next: %p\n",current->next);
        printf("valor current->number: %d\n",current->number);
    }

    return 0;
}

Aurelio ML

student•

Hola. ¿Qué libro me recomiendan para complementar el curso?

Alex Camacho

teacher•

Hola, Podrías intentar con la Biblia de C/C++ es un libro que va desde cero a los detalles :)

Aurelio ML

student•

Muchas gracias, lo leeré :3

marco antonio

student•

ok dejo mi código pasado con su explicación por si les sirve

#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;
}```

Alejandro Ruiz

student•

Alguien sabe de alguna clase de Platzi en la que expliquen el tema de Listas doblemente enlazadas? O si no lo hay, algun material en el que lo pueda consultar. Gracias!

Carlos Nassif Trejo Garcia

student•

Basicamente es como el que tenemos, solo que ademas del next tenemos un previous

code.soft 😶

student•

Hay un libro que lo estuve leyendo. esos conocimientos previos me hizo llevar este curso muy facil. La verdad yo sabia mas que el profesor 😂😂😂.

El libro se llama: Algoritmo a fondo con implementación en C, C++ y Java

LUIS ALEJANDRO BERNAL ROMERO

student•

¡Aqui está la explicación de lo que falto en la anteriore clase, liberar la memoria!

Ronald Rengifo

student•

hasta los punteros iba muy claro, luego cuando entramos en listas subió el nivel muy rápido, toca apoyarse con otros sitios

Francesco Franco

student•

Me apena tanto ver las críticas a este curso por su rápido avance, y en general opino que están en lo correcto.

Este curso a alguien que se está introduciendo en C evidentemente le resultará confuso y difícil de comprender. En mi caso aprendí lo básico de internet y llevé este curso para reforzar, y debo decir que está a millas de lo que se encuentra en la red y, a menos que lleves una carrera de este tipo, este material es sumamente valioso y por ello lo considero de los mejores cursos que he llevado.

Una pena el nombre del curso, debidó centrarse puramente en incrementar el nivel base de C y recibir un nombre tipo Fundamentos de C Nivel 2

Joel Vicente Nieto Gómez

student•

![](

Juan Carlos Sánchez Villafrades

student•

¿En este caso no habría que liberar también la memoria ocupada por el auxiliar que utilizó (next)?

Marlon Iván De León Pérez

student•

No en realidad, ya que sólo es un puntero, no ocupa espacio que puedas liberar de esa forma. En este caso no estás reservando espacio en memoria al utilizar next.

Alejandro Ruiz

student•

Alguien sabe de alguna clase de Platzi en la que expliquen el tema de Listas doblemente enlazadas? O si no lo hay, algun material en el que lo pueda consultar. Gracias!

Jose Adriel Madrigal Gonzalez

student•

Hola desconozco si en platzi esta ese tema, luego intentaré investigar

Pero este es un video que explica esos temas, tambien te recomiendo que veas sus otros videos ya que listas doblementes enlazadas son un concepto que se entiendes despues de entender listas enlazadas simples

https://www.youtube.com/watch?v=JdQeNxWCguQ https://www.youtube.com/watch?v=njTh_OwMljA

Espero te sean de ayuda, buen dia!

Filippo Cucina

student•

El curso basico de algoritmos

Oscar Jaramillo

student•

Jose Antonio Rojas Ollarves

student•

Este es el: Link del curso de algoritmos

Josué Esteban Cordero Ruvalcaba

student•

Deberían quitarle el título de "curso de introducción a c" y dejarlo en solo curso de c con algo de conocimientos previos, yo ya he estudiado algo del lenguaje y aún así tengo que estar muy atento para no perder la pista jaja, y la verdad si está un poco difícil para los que apenas se están iniciando en programación, hay algunos temas que se necesitan profundizar más para poder interiorizarlos. Aun así me gusta el curso, pero no diría lo mismo si no tuviera algo de conocimientos previos jaja

Jean Nuñez

student•

liberar memoria es importante cuando se trabaja con las lista enlazadas

Mauricio David Cuello Alzate

student•

Hola Como se copia y pega en vim?

jose luis gonzalez aguilera

student•

hola, aqui un link https://blog.carreralinux.com.ar/2017/09/copiar-y-pegar-con-vim-cortar-deshacer/

Agustin Isaias Salinas Quinteros

student•

no me da ese comando :-(

Hector Esau

student•

¿Por qué no? Había una lectura de como instalarlo

Rubén Domínguez Prieto

student•

pienso lo mismo

Jesús Ignacio García Fernández

student•

Mi versión del ejercicio

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

typedef struct Node
{
	int number;
	struct Node * next;
} NODE;

NODE	* createNode(int number)
{
	NODE *newNode;
	newNode = malloc (sizeof(NODE));
	newNode->number = number;
	newNode->next = NULL;
	return (newNode);
}

void	imprimeNodes(NODE *node)
{
	NODE *current = node;
	while(current)
	{
		printf("\t posMemoria %p, numero: %d, siguiente puntero %p", current, current->number, current->next);
		if(current->next)
			printf(";\n");
		else
		{
			printf("\n");
		}
		current = current->next;
	}
}

void	liberaMemoriaNodes(NODE *node)
{
	NODE *current;
	NODE *aux;
	current = node;
	while(current)
	{
		aux = current->next;
		free(current);
		current = aux;
	}
}

int main(int argc, char const *argv[])
{
	NODE *start;
	NODE *current;
	int number;
	int listSize;

	listSize = 0;
	start = NULL;
	do
	{
		printf("introduzca nuevo nodo actualmente hay %d nodes (0 para salir):", listSize);
		scanf("%d", &number);
		if(number)
		{
			if(!start)
			{
				printf("\tcreando nuevo nodo sin valor del puntero %p\n", start);
				start = createNode(number);
				listSize++;
				printf("\tasignado valor al puntero %p\n", start);
			}
			else
			{
				printf("\texiste el nodo start %d, valor del puntero %p, valor del puntero siguiente %p\n", start->number, start, start->next);
				current = start;
				printf("\tcopiado el nodo start %d, valor del puntero %p, valor del puntero siguiente %p\n", current->number, current, current->next);
				while (current->next)
				{
					printf("\t\texite el nodo current %d, valor del puntero %p, valor del puntero siguiente %p\n", current->number, current, current->next);
					current = current->next;
					printf("\t\tcopiado el nodo siguiente %d, valor del puntero %p, valor del puntero siguiente %p\n", current->number, current, current->next);
				}
				printf("\tcreando nuevo nodo sin valor del puntero %p\n", current->next);
				current->next = createNode(number);
				printf("\tasignado valor al puntero %p\n",  current->next);
				listSize++;
			}
			printf("\taumentando el valor del contador de nodos\n");
		}
	}
	while (number);
	printf("Pintando la lista de nodos\n");
	imprimeNodes(start);
	liberaMemoriaNodes(start);
	return (0);
}

Salida

valgrind ./listaEnlazada                                
==21262== Memcheck, a memory error detector
==21262== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==21262== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==21262== Command: ./listaEnlazada
==21262== 
==21262== error calling PR_SET_PTRACER, vgdb might block
introduzca nuevo nodo actualmente hay 0 nodes (0 para salir):1
        creando nuevo nodo sin valor del puntero (nil)
        asignado valor al puntero 0x522d8c0
        aumentando el valor del contador de nodos
introduzca nuevo nodo actualmente hay 1 nodes (0 para salir):2
        existe el nodo start 1, valor del puntero 0x522d8c0, valor del puntero siguiente (nil)
        copiado el nodo start 1, valor del puntero 0x522d8c0, valor del puntero siguiente (nil)
        creando nuevo nodo sin valor del puntero (nil)
        asignado valor al puntero 0x522d910
        aumentando el valor del contador de nodos
introduzca nuevo nodo actualmente hay 2 nodes (0 para salir):0
Pintando la lista de nodos
         posMemoria 0x522d8c0, numero: 1, siguiente puntero 0x522d910;
         posMemoria 0x522d910, numero: 2, siguiente puntero (nil)
==21262== 
==21262== HEAP SUMMARY:
==21262==     in use at exit: 0 bytes in 0 blocks
==21262==   total heap usage: 4 allocs, 4 frees, 2,080 bytes allocated
==21262== 
==21262== All heap blocks were freed -- no leaks are possible
==21262== 
==21262== For counts of detected and suppressed errors, rerun with: -v
==21262== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Joan Benavides Olivera

student•

Buenas. Paso mi ejemplo por aquí en el cual se genera una cantidad total de nodos de forma aleatoria y dónde el números de cada nodo también se genera de forma aletoria, en vez de tener que pasar los valores por pantalla.

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

//A node struct references itself
typedef struct Node{
    int number;
    struct Node * next;
} NODE;

//Create a new node a return a pointer that pointing the new node
NODE * create_node( int number )
{
  //NODE pointer
  NODE * node;
  //lock memory for the new NODE pointer
  node = malloc( sizeof(NODE) );
  //(*node).next == node->next
  node->next = NULL;
  //(*node).number == node->number
  node->number = number;
  //return the pointer
  return node;
}

//main function
int main(int argc, const char * argv[])
{
  //int = (rand() % (upper - lower + 1)) + lower;
  //return a generated integer value among min-max
  //(int)(rand() % (max - min + 1)) + min;
  srand(time(0));

  //pointer that starts the linked list
  NODE * init = NULL, * current, *aux_free_memory;

  //It returns a random values inside the range 1-9
  int seed = 0;
  int random_nodes_quantity = (rand() % (9 - 1 + 1)) + 1;

  //Create all linked list with random values inside the range 1-9
  int counter = 0;
  while(counter < random_nodes_quantity)
  {
    //check if init == NULL
    if( !init )
    {
      //It returns a node pointer with a random number inside the range 1-9 and pass it into 'init'
      init = create_node( (rand() % (9 - 1 + 1)) + 1 );
    }
    else
    {
      //set the current pointer as init node, so current pointer points to the 2nd node of the linked
      //list just as init node does. Current pointer is ready to start iteration.
      current = init;

      //check if current->next is not NULL
      while( current->next )
      {
          //If the next node exists current->next value is not null and current pointer changes to
          //point the next node.
          current = current->next;
      }
      //when current pointer finishes the iteration that means current->next value is null. This is
      //the ending of linked list and here a new node is set
      current->next = create_node( (rand() % (9 - 1 + 1)) + 1 );

      //increment counter in order to reach the limit of main while's loop
      counter++;
    }

  }

  //set the current pointer as init node, so current pointer points to the 2nd node of the linked
  //list just as init node does. Current pointer is ready to start iteration.
  current = init;
  int i = 0;
  //check if current->next is not NULL
  printf("List's numbers\n");
  while( current->next )
  {
    printf("%d. %d\n",i+1,current->number);
    //If the next node exists current->next value is not null and current pointer changes to
    //point the next node.
    current = current->next;
    i++;
  }

  //set the current pointer as init node, so current pointer points to the 2nd node of the linked
  //list just as init node does. Current pointer is ready to start iteration.
  current = init;

  //check if current->next is not NULL
  while( current->next )
  {
    //aux_free_memory pointer will point the next node that 'current' pointer is pointing to
    aux_free_memory = current->next;
    //the current node that 'current' pointer is pointing to gets the memory free.
    free(current);
    //'current' pointer change to pointing the next node 
    current = aux_free_memory;
  }

  //There is a remaining memory that current uses and it must be got free
  free(current);
  return 0;
}

El hacerlo me ha ayudado a entender mejor el ejercicio ya que lo encontraba un poco lío pero al final termina por entenderse.