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

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

Contenido del curso

Comprender qué es el lenguaje C

Aprender los conceptos iniciales del lenguaje C

Entender conceptos más profundos del lenguaje C

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

Usos prácticos

Comunicación entre procesos

Conclusiones

37
Conclusiones
01:20 min

Tomar examen

Partiendo del código que se encuentra en https://raw.githubusercontent.com/mchojrin/platzi_curso_c_clases/2b66b7e0178c0ae13c9434e3bf9eb08a8aad0434/linked_list.c realiza las modificaciones necesarias para poder eliminar nodos.

Tips

Suponiendo que la lista está de esta forma:

Nos encontramos con estos casos:

El nodo que queremos eliminar no existe
El nodo que queremos eliminar no es el primero
El nodo que queremos eliminar es el primero

Si el nodo no existe

Este es el caso más simple, sólo se recorrerá la lista y quedará igual que al comienzo.

Si el nodo no es el primero

En este caso tendremos que saber siempre cuál era el nodo anterior para, una vez eliminado el buscado, apuntar el siguiente del anterior al siguiente del eliminado.

Si el nodo es el primero

Este es un caso especial por dos razones:

No existe un nodo anterior
Al finalizar la eliminación también deberemos modificar el comienzo de la lista

Tu tarea: escribir el código!

#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, *next, *aux; // 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, index, currentIndex; //listSize es el tamaño de la lista

    do {
        printf("La lista contiene %d nodos. Ingrese el siguiente número (0 para finalizar)\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
                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
                while(current->next){ // Mientras current tenga algo en su next
                    current = current->next; // Current sea igual al siguiente
                    // Avanza entre los nodos, termina cuando no tiene siguiente
                }
                // El siguiente sera el nodo que se creara
                current->next = createNode(number); //asi queda encadenado
                listSize++;
            }
            goOn =  1;
        } else {
            goOn = 0;
        }
    } while( goOn );  // Se detiene si goOn es 0

    current = start;  // Inicializa el nodo current con el inicio;
    printf( "La lisa contiene los numeros: \n" );
    while (current) { // Mientras current no sea null
        printf( "%d", current->number ); // 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
    }

    printf("\n\n\nLe gustaria eliminar algún nodo? (Escriba 1 para si, escriba 0 para no)\n");
    scanf("%d",&goOn);

    if( goOn ) {
        printf("\n\nEscriba el index del nodo a eliminar: \n");
        scanf("%d", &index);
        //printf("\n\n Se eliminara este index %d \n", index);
        current = start;
        currentIndex = 0;

        while (current) {
            next = current->next;
            //printf("Nodo actual %d\n", current->number );
            //printf("Index actual %d\n", current);
            if(currentIndex==index) {
                printf("El numero del nodo a eliminar es %d\n", current->number);
                //printf("%d\n", current->next);
                if(!index) {
                    printf("Es el primero");
                    start=current->next;
                    free( current );
                    current=0;
                } else {
                    aux = current->next;
                    free( current ); // Libera el nodo actual
                    current = start;
                    index = 0;
                    while(current) {
                        //printf("current->number, %d", current->number);
                        current = current->next;
                        if(currentIndex-2==index) {
                            current->next = aux;
                            current=0;
                        }
                        index++;
                    }
                }
            } else {
                currentIndex++;
                current = next;
                //printf("next %d\n", next);
                if(!next) {
                    printf("El index %d es inexistente.", index);
                }
            }
        }
    }


    current = start;  // Inicializa el nodo current con el inicio;
    printf( "\n\nNueva lista de numeros: \n" );
    while (current) { // Mientras current no sea null
        printf( "%d", current->number ); // 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;
    while (current) {
        next = current-> next;
        free( current ); // Libera el nodo actual
        current = next;
    }

    return 0;
}

#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->next = NULL;
	newNode->number = number;

	return newNode;
}

int main( int argc, const char * arg[] )
{
	NODE * start = NULL, *current, *next, *previous;
	char goOn, goOn2;
	int listSize = 0, number, option, numberToDelete, i, position, exist, k;

	do {
		if ( !listSize ){
			printf ("=======================\n");
			printf ("1 - Ingresar nodos \n");
			printf ("0 - Salir \n");
			printf ("=======================\n");
			scanf ("%d", &option );
			
			switch ( option ) {
			
			    case 1:
				do {
					printf( "La lista contiene %d nodos. Ingrese el siguiente numero (0 para regresar)\n", listSize );
					scanf("%d", &number );
					if ( number ) {
						
						if ( !start ) {
							start = createNode( number );
							listSize++;
						} else {
							current = start;
							while ( current->next ) {
								current = current->next;
							}
							current->next = createNode( number );
							listSize++;
						}
						goOn2 = 1;
					} else {
						printf ("0 para regresar\n" );
						goOn2 = 0;
						goOn = 1;
					}
				} while ( goOn2 );
				break;
			    case 0:
			    	
			    	goOn = 0; 
			    	break;
			    default:
			    	printf( "Opcion no valida \n");
			    	goOn = 1;
			    	break; 	    	
			}	
		} else {
			printf ("=======================\n");
			printf ("1 - Ingresar nodos \n");
			printf ("2 - Eliminar nodos \n");
			printf ("3 - Ver lista de nodos \n");
			printf ("0 - Salir \n");
			printf ("=======================\n");
			scanf ("%d", &option );
		
			switch ( option ) {
			
			    case 1:
				do {
					printf( "La lista contiene %d nodos. Ingrese el siguiente numero (0 para regresar)\n", listSize );
					scanf("%d", &number );
					if ( number ) {
						if ( !start ) {
							start = createNode( number );
							listSize++;
						} else {
							current = start;
							while ( current->next ) {
								current = current->next;
							}
							current->next = createNode( number );
							listSize++;
						}
						goOn2 = 1;
					} else {
						
						goOn2 = 0;
						goOn = 1;
					}
				} while ( goOn2 ); 	
			 	break;
			 
			    case 2:
			 	
			 	
			 	current = start;
				printf( "La lista contiene los numeros: \n" );
				while (current) {
					printf( "%d", current->number );
					printf( current->next ? ", " : "\n" );
					current = current->next;
				}
				
				printf ("Que numero desea eliminar \n");
				scanf ("%d", &numberToDelete );
				
				
				
				
				/* recorremos la lista para encontrar el nodo a eliminar */
				
				current = start;
				i = 1;
				exist = 0;
				position = 0;
				while (current) {
					if ( numberToDelete == current->number ) {
						exist = 1;
						if ( !position ) { position = i; }
						
					}
					current = current->next;
					i++;
				}
				
				
				if ( exist ) {
					
					
					if ( position == 1 ) {
				          	/* El nodo que queremos eliminar es el primero */
						current = start;
						start = current->next;
						free ( current );
						listSize--;
						
					} else {
						/* El nodo que queremos eliminar no es el primero */
						
						current = start;
						for ( k = 1; k < position; k++ ) {
							/* printf ("%d \n", current->number ); */
							previous = current;
							current = current->next;
						}
						previous->next = current->next;
						free ( current );
						listSize--;	
					}
				
				} else {
				
					printf ( "El nodo que queremos eliminar no existe \n" );
				}
				
			 	break;
			
			    case 3:
			    
			    	current = start;
				printf( "La lista contiene los numeros: \n" );
				while (current) {
					printf( "%d", current->number );
					printf( current->next ? ", " : "\n" );
					current = current->next;
				}
			    	break; 
			 
			    case 0:
			    	goOn = 0;
			    	break;
			
			    default:
			    	printf( "Opcion no valida \n");
			    	break;
			}
		}
		
	} while ( goOn );

	/* liberar memoria ocupada por los nodos */
	printf ( "Limpiando memoria \n" );
	current = start;
	while (current) {
		next = current->next;
		free ( current );
		current = next;
	}
	return 0;
}

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

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

struct {
	int * position;
	int counter;
} seeker;

NODE * createNode( int number )
{
	NODE * newNode;

	newNode = (NODE *) malloc( sizeof(NODE) );
	newNode->next = NULL;
	newNode->head = 0; // por defecto no asignaré como head a ningún nodo, lo haremos en la función seekPositions 
	newNode->number = number;

	return newNode;
}

void cleanNodes(NODE * linkedListToClean){
	NODE * tempVar;

		while (linkedListToClean)
		{
			tempVar = linkedListToClean->next;
			free(linkedListToClean);
			linkedListToClean = tempVar;
		}
}

void seekPositions(int number, NODE * linkedList){ // función buscará las posiciones de los nodos
	int index = 0;
	seeker.counter = 0;
	seeker.position = NULL;
	free(seeker.position);
	
	if (!linkedList) // si la lista está vacía
	{
		printf("\nerror\n");
	} else
	{
		linkedList->head = 1;// definimos como head de la lista al primer nodo
		while (linkedList) // condicional que se repetirá hasta que se llegue al último nodo
		{
			seeker.counter++;
			if (number==linkedList->number)
			{
				if (index == 0)
				{
					seeker.position = (int *) malloc(sizeof(int)*(index+1));
					seeker.position[index] = seeker.counter;
					index++;
				} else
				{
					seeker.position =(int *) realloc(seeker.position,sizeof(int)*(index+1));
					seeker.position[index] = seeker.counter;
					index++;
				}
			}
			
			linkedList = linkedList->next;
		}
	}
}

void destroyNode(NODE * nodeToDestroy){
	free(nodeToDestroy);
}

void printListOfNodes(NODE * linkedList){
			if (!linkedList)
			{
				printf("Lista está vacía\n");
			}else
			{
				printf( "La lista contiene los numeros: \n" );
				while (linkedList) {
					printf( "%d", linkedList->number );
					printf( linkedList->next ? ", " : "\n" );
					linkedList = linkedList->next;
				}
			}
}

NODE * deleteNodesOfList(int * arrayNodePositionToDelete, NODE * listOfNodes){
	NODE * aux, *before, *newHead;
	int index= 0;
	int counter = 0;
	newHead = listOfNodes; // fijo el head en al variable newHead para retornarla

	while (listOfNodes)
	{	
		counter++;
		if (arrayNodePositionToDelete[index]==counter)
		{
			if (listOfNodes->head == 1)
			{
				if (listOfNodes->next)
				{
					aux = listOfNodes;
					listOfNodes = listOfNodes->next;
					destroyNode(aux);
					listOfNodes->head = 1;
					newHead = listOfNodes;
				} else
				{
					listOfNodes = NULL;
					destroyNode(listOfNodes);
					newHead = NULL;
				}
				
			} else
			{
				if (listOfNodes->next)
				{
					before->next = listOfNodes->next;
					aux = listOfNodes;
					listOfNodes = listOfNodes->next;
					destroyNode(aux);
				} else
				{
					before->next= NULL;
					aux = listOfNodes;
					listOfNodes = listOfNodes->next;
					destroyNode(aux);
				}
			}
			index++;				
		} else
		{
			before = listOfNodes;
			listOfNodes = listOfNodes->next;
		}
		
	}
	return newHead;
}


int main( int argc, const char * arg[] )
{
	NODE * start = NULL, * current;
	char goOn;
	int listSize = 0, number;

	do {//empieza loop para capturar datos del usuario, ingresar datos a lista
		printf( "La lista contiene %d nodos. Ingrese el siguiente numero (0 para finalizar)\n", listSize );
		scanf("%d", &number );
		if ( number ) {
			if ( !start ) {
				start = createNode( number );
				listSize++;
			} else {
				current = start;
				while ( current->next ) {
					current = current->next;
				}
				current->next = createNode( number );
				listSize++;
			}
			goOn = 1;
		} else {
			printListOfNodes(start);
			goOn = 0;
		}
	} while ( goOn );
	
	if (start)
	{
		do{		// empieza loop para capturar datos del usuario, datos a eliminar de lista
		printf("¿Desea eliminar algún nodo? (1 para confirmar, cualquier número para cancelar)\n");
		scanf("%d",&number);
			if (number== 1)
			{
				printf("¿Cuál dato desea eliminar?\n");
				scanf("%d",&number);
				seekPositions(number,start);//buscamos number en lista
				if (seeker.position == NULL)// si el número no está en lista, solicitamos un dato nuevamente
				{
					printf("El número %d no ha sido encontrado\n",number);
					printListOfNodes(start);
					goOn = 1;
				} else
				{
					start= deleteNodesOfList(seeker.position,start);// eliminamos las posiciones en las que está el número
					printListOfNodes(start);
					goOn = 1; 
				}
				if (!start)
				{
					goOn = 0;
				}
			} else
			{
				printListOfNodes(start);
				goOn = 0;
			}
		} while (goOn);
	}

	cleanNodes(start);
	free(seeker.position);
	return 0;
}

#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->next = NULL;
	newNode->number = number;

	return newNode;
}

int main( int argc, const char * arg[] )
{
	NODE *start = NULL, *current, *next, *previous;
	int listSize = 0, number, goOn;

	do {
		printf( "La lista contiene %d nodos. Ingrese el siguiente numero (0 para finalizar)\n", listSize );
		scanf("%d", &number );
		if ( number ) {
			if ( !start ) {
				start = createNode( number );
				listSize++;
			} else {
				current = start;
				while ( current->next ) {
					current = current->next;
				}
				current->next = createNode( number );
				listSize++;
			}
			goOn = 1;
		} else {
			goOn = 0;
		}
	} while ( goOn );

	current = start;
	printf( "La lista contiene los numeros: \n" );
	while (current) {
		printf( "%d", current->number );
		printf( current->next ? ", " : "\n" );
		current = current->next;
	}

	do {
		printf("Deseas eliminar numeros? Digite: ");
		scanf("%d", &number);
		if (number)
		{
			current = start;
			while (current)
			{
				next = current->next;
				if (start->number == number)
				{
					free(start);
					start = next;
					current = start;
				}
				
				if (current->number == number && start->number != number)
				{
					previous->next = current->next;
					free(current);
				}
				
				previous = current;
				current = next;
			}
			goOn = 1;
		}else
		{
			goOn = 0;
		}
	} while (goOn);
	
	current = start;
	printf( "La lista contiene los numeros: \n" );
	while (current) {
		printf( "%d", current->number );
		printf( current->next ? ", " : "\n" );
		current = current->next;
	}
	
	current = start;
	while (current) {
		next = current->next;
		free( current );
		current = next;
	}
	return 0;
}

	do{
		printf(&quot;Ingresa el numero del nodo que deseas borrar (introduce 0 para finalizar): &quot; );
		scanf(&quot;%d&quot;, &amp;number );
		printf(&quot;\n&quot;);
		if ( number ) {
			if(start-&gt;number == number ) {
				next = start-&gt;next;
				free( start );
				start = next;
				goOn = 0;
			} else {
				before = start;
				current = start-&gt;next;
				while( current ) {
					if( current-&gt;number == number) {
						before-&gt;next = current-&gt;next;
						free( current );
					} else {
						before = current;
						current = current-&gt;next;
					}
				}
			}
			goOn = 1;
		} else {
			goOn = 0;
		}
		
	} while( goOn );

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

#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->next = NULL;
    newNode->number = number;

    return newNode;
}

int main( int argc, char * argv[] )
{
    NODE * start = NULL, * current, * next, * previous;
    char goOn;
    int listSize = 0, number, badNode, position = 1;

    do {
        printf( "La lista tiene %d nodos. Ingrese el siguiente numero (0 para finalizar)\n", listSize );
        scanf("%d", &number);
        if( number ) {
            listSize++;
            if ( !start ) {
                start = createNode( number );
            }
            else {
                current = start;
                while ( current->next ){
                    current = current->next;
                }
                current->next = createNode( number );
            }
            goOn = 1;
        }
        else {
            goOn = 0;
        }
    } while ( goOn );

    printf("Cual es la posicion del nodo a eliminar? (Comenzando en 1) ");
    scanf("%d", &badNode);
    current = start;

    while (current) {
        next = current->next;
        if(position == badNode) {
            if(position == 1) {
                free(current);
                start = next;
            }
            else {
                free(current);
                previous->next = next;
            }
            break;
        }
        previous = current;
        current = next;
        position++;
    }
    
    current = start;
    printf("La lista contiene los numeros: \n");
    while (current) {
        next = current->next;
        printf( "%d", current->number );
        printf( current->next ? ", " : "\n");
        free(current);
        current = next;
    }
    return 0;
}

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

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

NODE * createNode( int number )
{
    NODE * newNode;

    newNode = malloc( sizeof(NODE) );
    newNode-&gt;next = NULL;
    newNode-&gt;number = number;

    return newNode;
}

void deleteNode(int number, NODE * * start, int * cant){
    if(number &amp;&amp; *start){
        NODE * current, * prev = NULL;
        current = *start;
        do{
            if (current-&gt;number == number)
            {
                if(!prev){
                    *start = current-&gt;next;
                    free(current);
                    current = *start;
                    (*cant)--;
                    if(!*start){
                        break;
                    }
                }
                else
                {
                    prev-&gt;next = current-&gt;next;
                    free(current);
                    current = prev-&gt;next;
                    (*cant)--;
                }
            }
            else
            {
                prev = current;
                current = current-&gt;next;
            }
        } while ( current );
    }
    
}

int main( int argc, const char * arg[] )
{
    NODE * start = NULL, * current, * next;
    char goOn;
    int listSize = 0, number;
    do {
        printf( &quot;La lista contiene %d nodos. Ingrese el siguiente numero (0 para finalizar)\n&quot;, listSize );
        scanf(&quot;%d&quot;, &amp;number );
        if ( number ) {
            if ( !start ) {
                start = createNode( number );
            } else {
                current = start;
                while ( current-&gt;next ) {
                    current = current-&gt;next;
                }
                current-&gt;next = createNode( number );
            }
            listSize++;
            goOn = 1;
        } else {
            goOn = 0;
        }
    } while ( goOn );

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

    printf( &quot;La lista contiene %d nodos. Ingrese el número a eliminar (0 para finalizar)\n&quot;, listSize );
    scanf(&quot;%d&quot;, &amp;number );
    if ( number ) {
        deleteNode(number,&amp;start, &amp;listSize);
    }

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

    current = start;
    while (current) {
        next = current-&gt;next;
        free(current);
        current = next;
    }

    return 0;
}

do {
        printf(&quot;Quieres eliminar algún nodo? (presiona 0 para salir) \n&quot;);
        scanf(&quot;%d&quot;, &amp;number);
        printf(&quot;\n&quot;); 

        if(number){
            if (start-&gt;number == number) {
                next = start-&gt;next;
                free(start);
                start = next;
                goOn = 0;
                listSize--;
                printf(&quot;El número %d se eliminó.\n&quot;, number);
            } else {
                before = start;
                current = start-&gt;next;
                while(current) {
                    if (current-&gt;number == number) {
                        before-&gt;next = current-&gt;next;
                        free(current);
                        listSize--;
                        printf(&quot;El número %d se eliminó.\n&quot;, number);
                    } else {
                        before = current;
                        current = current-&gt;next;
                    }
                }
                printf(&quot;El número %d no está en la lista\n&quot;, number);

            }
            goOn = 1;
        } else {
            goOn = 0;
        }
    } while (goOn);

#include <stdio.h>

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

NODE *start = NULL, *current, *next;

NODE *createNode(int number)
{
	NODE *newNode;

	newNode = malloc(sizeof(NODE));
	newNode->next = NULL;
	newNode->number = number;

	return newNode;
}

void removeNodeFromList(int number) {
	int goOn = 1;
	
	current = start;
	while (current && goOn) {
		if (current->number == number) {
			start = current->next;
			goOn = 0;
		} else {
			if (current->next->number == number) {
				current->next = current->next->next;
				goOn = 0;
			}
		}
		current = current->next;
	}
}

void cargarNodos() {
	char goOn;
	int listSize = 0, number;
	
	do {
		printf( "La lista contiene %d nodos. Ingrese el siguiente numero (0 para finalizar)\n", listSize );
		scanf("%d", &number );
		if ( number ) {
			if ( !start ) {
				start = createNode( number );
				listSize++;
			} else {
				current = start;
				while ( current->next ) {
					current = current->next;
				}
				current->next = createNode( number );
				listSize++;
			}
			goOn = 1;
		} else {
			goOn = 0;
		}
	} while ( goOn );
}

void imprimirNodos() {
	current = start;
	
	printf( "La lista contiene los numeros: \n" );
	while (current) {
		printf( "%d", current->number );
		printf( current->next ? ", " : "\n" );
		current = current->next;
	}
}

void liberarMemoria() {
	current = start;
	while (current) {
		next = current->next;
		free( current );
		current = next;
	}
}

int main() {
	cargarNodos();
	
	imprimirNodos();
	removeNodeFromList(2);
	imprimirNodos();
	
	// OPCIONAL: para liberar memoria.
	liberarMemoria();
	
	system("pause");
	return 0;
}```

void removeFromList(LIST *list, int target)
{
    list->lenght--;
    NODE **indirect = &(list->root);
    while ((*indirect)->content != target)
    {
        indirect = &(*indirect)->next;
    }   
    *indirect = (*indirect)->next;
}

#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->next = NULL;
    newNode->number = number;

    return newNode;
}

NODE * deleteNode( NODE * list, int number ) {
    NODE * aux = list;

    if (aux->number == number) {
        list = aux->next;

        free(aux);
    }
    else {
        while(aux->next->number != number)
            aux = aux->next;

        NODE * toDelete = aux->next;

        aux->next = aux->next->next;

        free(toDelete);
    }

    return list;
}

int main( int argc, const char * arg[] )
{
    NODE * start = NULL, * current, *next;
    char goOn;
    int listSize = 0, number;

    do {
        printf( "La lista contiene %d nodos. Ingrese el siguiente numero (0 para finalizar)\n", listSize );
        scanf("%d", &number );
        if ( number ) {
            if ( !start ) {
                start = createNode( number );
                listSize++;
            } else {
                current = start;
                while ( current->next ) {
                    current = current->next;
                }
                current->next = createNode( number );
                listSize++;
            }
            goOn = 1;
        } else {
            goOn = 0;
        }
    } while ( goOn );

    current = start;
    printf( "La lista contiene los numeros: \n" );
    while (current) {
        printf( "%d", current->number );
        printf( current->next ? ", " : "\n" );
        current = current->next;
    }

    int nodoABorrar;

    printf("Por favor ingrese el numero de nodo a borrar: ");
    scanf("%d",&nodoABorrar);


    printf("Vamos a borrar el nodo con numero %d\n",nodoABorrar);
    start = deleteNode(start,nodoABorrar);
    current = start;

    printf( "La lista queda asi: \n" );
    while (current) {
        printf( "%d", current->number );
        printf( current->next ? ", " : "\n" );
        current = current->next;
    }

    current = start;
    while (current) {
        next = current->next;
        free( current );
        current = next;
    }

    return 0;
}

#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->next = NULL;
    newNode->number = number;

    return newNode;
}

NODE * deleteNode( NODE * list, int number ) {
    NODE * aux = list;

    if (aux->number == number) {
        list = aux->next;

        free(aux);
    }
    else {
        while(aux->next->number != number)
            aux = aux->next;

        NODE * toDelete = aux->next;

        aux->next = aux->next->next;

        free(toDelete);
    }

    return list;
}

int main( int argc, const char * arg[] )
{
    NODE * start = NULL, * current, *next;
    char goOn;
    int listSize = 0, number;

    do {
        printf( "La lista contiene %d nodos. Ingrese el siguiente numero (0 para finalizar)\n", listSize );
        scanf("%d", &number );
        if ( number ) {
            if ( !start ) {
                start = createNode( number );
                listSize++;
            } else {
                current = start;
                while ( current->next ) {
                    current = current->next;
                }
                current->next = createNode( number );
                listSize++;
            }
            goOn = 1;
        } else {
            goOn = 0;
        }
    } while ( goOn );

    current = start;
    printf( "La lista contiene los numeros: \n" );
    while (current) {
        printf( "%d", current->number );
        printf( current->next ? ", " : "\n" );
        current = current->next;
    }

    int nodoABorrar;

    printf("Por favor ingrese el numero de nodo a borrar: ");
    scanf("%d",&nodoABorrar);


    printf("El numero eliminado es el %d\n",nodoABorrar);
    start = deleteNode(start,nodoABorrar);
    current = start;

    printf( "Lista modificada: \n" );
    while (current) {
        printf( "%d", current->number );
        printf( current->next ? ", " : "\n" );
        current = current->next;
    }

    current = start;
    while (current) {
        next = current->next;
        free( current );
        current = next;
    }

    return 0;
}

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

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

//crea un nuevo nodo y devuelve su direccion.
NODE * createNode(int number){
    NODE * newNode;
    newNode = malloc(sizeof(NODE));
    newNode->next = NULL;
    newNode->number = number;
    return newNode;
}

int main(int argc, const char * argv[])
{
    NODE * start = NULL;
    NODE * current;
    NODE * next;
    NODE * prev;//es para para conocer la direccion del nodo anterior (previous) y cambiar su .next.
    int go_on;
    int list_size = 0;
    int number;//valor almacenado en el nodo.
    do{
        printf("La lista contiene %d nodos. Ingrese el siguiente numero (0 para finalizar)\n", list_size);
        scanf("%d", &number);
        if(number){
            if(!start){
                start = createNode(number);
            } else{
                current = start;
                while(current->next){
                    current = current->next;
                }
                current->next = createNode(number);
            }
            go_on = 1;
            list_size++;
        }else{
            go_on = 0;
        }
    }while(go_on);

    printf("La lista contiene los numeros:\n");

    current = start;
    while (current){
        printf("%d\n", current->number);
        current = current->next;
    }

    //Eliminar nodos--------------------------------------------------------------------------------------------------------
    do{
        printf("La lista contiene %d nodos. Ingrese el numero que desee eliminar (0 para finalizar)\n", list_size);
        scanf("%d", &number);
        if(number){
            current = start;
            while(current){
                next = current->next;
                if(number == current->number){
                    if(current == start){
                        start = current->next; //si el nodo que se borra es el start, el nuevo start sera el siguiente nodo.
                        free(current);
                    }else{
                        prev->next = current->next; //si se elimina un nodo que no es el primero, el next del anterios sera el next del que se va a eliminar.
                        free(current);
                    }
                    list_size--; 
                }else{
                    prev = current; //si no se borro el nodo actual, entonces sera el prev del siguinte
                }
                current = next;
            }
            go_on = 1;
        }else{
            go_on = 0;
        }
    }while(go_on);
    //Eliminar nodos--------------------------------------------------------------------------------------------------------

    printf("La lista contiene los numeros:\n");

    current = start;
    while (current){
        printf("%d\n", current->number);
        current = current->next;
    }

    current = start;
    while (current){
        next = current->next;
        free(current);
        current = next;
    }
    
    return 0;
}```

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

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


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

    return newNode;
}

void printLinkedList( NODE *linkedList )
{
    NODE *current, *old;
    current = linkedList;

    while ( current ) {
        printf("%d", current->number);
        printf(current->next ? ", " : "\n");

        current = current->next;
    }

    while ( current ) {
        old = current;
        current = current->next;
        free(old);
    }
}

void freeList( NODE *linkedList )
{
    NODE *current;

    while ( linkedList ) {
        current = linkedList->next;
        free(linkedList);
        linkedList = current;
    }
    
}

NODE *deleteNode( NODE *linkedList, int nodeToDelete )
{
    NODE *current, *oldNode;
    current = linkedList;
    
    do {
        if ( current ) {
            if ( current->number == nodeToDelete ) {
                if ( current == linkedList ) {
                    linkedList = current->next;
                    free(current);
                    return linkedList;
                } else {
                    oldNode->next = current->next;
                    free(current);
                    return linkedList;
                }
            } else {
                oldNode = current;
            }
        } else {
            oldNode->next = NULL;
            free(current);
            return linkedList;
        }

        current = current->next;
    } while ( current );

    return linkedList;
}

int main( int argc, const char *argv[] )
{
    NODE *start = NULL, *current, *old;
    char goOn;
    int listSize = 0, buffer;

    do {
        printf("La lista contiene %d nodos. (0 para finalizar)\n", listSize);
        scanf("%d", &buffer);

        if ( buffer ) {
            if ( !start ) {
                start = createNode(buffer);
            } else {
                current = start;

                while ( current->next ) {
                    current = current->next;
                }

                current->next = createNode(buffer);
            }

            goOn = 1;
        } else {
            goOn = 0;
        }
    } while ( goOn );

    printf("La lista contiene los numeros: ");
    printLinkedList( start );

    printf("Escriba el conteniso del nodo que desea eliminar: \n");
    scanf("%d", &buffer);

    start = deleteNode( start, buffer );
    printLinkedList( start );    

    freeList(start);

    return 0;
}

#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->next = NULL;
	newNode->number = number;

	return newNode;
}

//cree una funcion para imprimir la lista enlazada
void imprimirLista(NODE * start){
    
    NODE * current = start;
    while (current) {
		printf( "%d", current->number );
		printf( current->next ? ", " : "\n" );
		current = current->next;
	}
}//imprimr

//funcion eliminar nodo
NODE * eliminarNodo(NODE * start, int number){
    NODE * current = start;//asignar valores para empezar a recorrer
    NODE * next, *previus;//nodos auxiliares que nos serviran para reacomodar la lista

    while (current) {//Comienza el recorrido de la lista para buscar el numero pedido
		if(current->number==number){//Se encuentra el numero solicitado
            if (current==start)//Caso 3 del desafio
            {
                next = start->next;//el nodo next sera a donde apunta next del primer nodo
                free(start);//se borra el inicio
                current=next;//el nodo actual para el recorrido de la lista es igual a next
                start=current;//el inicio(start) queda declarado como el nodo actual del recorrido
            }else{// Caso 2 del desafio
                previus->next = current->next;//el nodo anterior apuntara al next del nodo actual del recorrido
                free(current);// se elimina el nodo solicitado
                current=previus;//el nodo actual para a ser el nodo previo pero apuntando al nodo siguiente que le corresponde
            }  
		}//Caso 1 del desafio, si no se cumplen las condicion la lista se recorre normalmente
		previus = current;//aqui se guarda el nodo anterior, necesario para el caso 2 del desafio
    	current = current->next;// se recorre
	}
	return start;
}//eliminar nodo

void liberarMemoria(NODE * start){
	NODE * next,* current = start;
	while(current){
        next = current->next;
        free( current );
        current = next;
    }

}//Liberar memoria

int main( int argc, const char * arg[] )
{
	NODE * start = NULL, * current, *next;
	char goOn;
	int listSize = 0, number;

	do {
		printf( "La lista contiene %d nodos. Ingrese el siguiente numero (0 para finalizar)\n", listSize );
		scanf("%d", &number );
		if ( number ) {
			if ( !start ) {
				start = createNode( number );
				listSize++;
			} else {
				current = start;
				while ( current->next ) {
					current = current->next;
				}
				current->next = createNode( number );
				listSize++;
			}
			goOn = 1;
		} else {
			goOn = 0;
		}
	} while ( goOn );

	printf( "La lista contiene los numeros: \n" );
    imprimirLista(start);

    printf("Ingresa el numero a eliminar:\n");
    scanf("%d", &number);

    start=eliminarNodo(start,number);
    imprimirLista(start);

	liberarMemoria(start);
    
	return 0;
}```
![desafio.PNG](https://static.platzi.com/media/user_upload/desafio-9b9e3e61-b8d6-4082-9366-7d1953e032cf.jpg)

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

// Define la estructura del Nodo.
typedef struct Node {
  int number;
  struct Node *next;
} NODE;

typedef struct{
	int status;
	NODE * start;
} removeNodeReturn;

//Functions declaration.
NODE *createNode(int number);
void printList(NODE *start, int listSize);
removeNodeReturn removeNode(NODE *listHead, int num);

int main(int argc, const char *argv[]) {
  // Crea la cabeza de la lista y un puntero axiliar para recorrer la lista..
  NODE *start = NULL, *current;

  // Contador para el tamaño de la lista.
  int listSize = 0;

  // Esta variable sirve como buffer para recivir el input.
  int number;

  do {
    printf("La lista contiene %d nodos. Ingresa el siguiente numero (0 para "
           "finalizar):\n",
           listSize);
    scanf("%d", &number);

    // Si el input es igual a 0, entonces rompemos el loop.
    if (!number) {
      break;
    }

    // Si la lista está vacia (start es igual a NULL) entonces inicializa la
    // cabeza.
    if (!start) {
      start = createNode(number);
    } else {
      // Si la lista ya existe, entonces la recorremos hasta el final.
      current = start;
      while (current->next) {
        current = current->next;
      }
      // Creamos un nuevo nodo y asignamos la dirección de memoría del nuevo
      // nodo a el valor next del ultimo en la lista.
      NODE *new = createNode(number);
      current->next = new;
    }
    listSize++;

  } while (1);

  while (1) {
    printList(start, listSize);
    int num;
    printf("Que numero desea eliminar? (si el numero esta repetido, se removerá el primero) 0 para cancelar:");
    scanf("%d", &num);
    if (!num) {
      break;
    }
    if (listSize == 1) {
      free(start);
      printf("La lista está vacía.\n");
      return 0;
    }
    removeNodeReturn response = removeNode(start, num);
    if (response.status) {
      listSize -= 1;
    }
    start = response.start;
  }

  printList(start, listSize);

  // Volvemos a recorrer la lista, pero en esta ocación para liberar la memoria.
  NODE *before;
  current = start;
  while (current) {
    before = current;
    current = current->next;
    free(before);
  }
  return 0;
}


// Funcción para reservar memoria y crear un nuevo nodo.
NODE *createNode(int number) {
  NODE *newNode;
  newNode = malloc(sizeof(NODE));
  newNode->next = NULL;
  newNode->number = number;
  return newNode;
}

void printList(NODE *start, int listSize) {
  // Recorremos la lista para mostrar los valores.
  NODE *current = start;
  printf("La lista contiene %d numeros: \n",listSize);
  while (current) {
    printf("%d", current->number);
    printf(current->next ? ", " : "\n");
    current = current->next;
  }
}

// La funcion para remover un nodo recive la cabeza de la lista y el numero que
// se va a remover. El nodo no se removerá cuando sea la cabeza, o cuando no
// exista. Retorna la cabeza de la lista modificada
removeNodeReturn removeNode(NODE *listHead, int num) {
  NODE *start = listHead;
  NODE *current = start;
  NODE *holder, *prev;
  int found = 0;

  while (current) {
    if (current->number == num) {
      found = 1;
      if (!current->next) {
        prev->next = NULL;
        free(current);
        break;
      }

      if (current == start) {
        holder = current;
        start = current->next;
        free(holder);
        break;
      } else {
        holder = current;
        prev->next = current->next;
        free(holder);
      }
    }
    prev = current;
    current = current->next;
  }
  removeNodeReturn returnValue;
  if (found) {
    printf("El numero %d ha sido eliminado exitosamente.\n", num);
	returnValue.status = 1;
	returnValue.start = start;
  } else {
    printf("El numero %d no hace parte de la lista.\n", num);

	returnValue.status = 0;
	returnValue.start = start;
  }
  return returnValue;
}

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

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

NODE * createNode( int number, int index )
{
	NODE * newNode;

	newNode = malloc( sizeof(NODE) );
	newNode->next = NULL;
	newNode->number = number;

	return newNode;
}

int main( int argc, const char * arg[] )
{
	NODE * start = NULL, * current, *next, *aux, *ant;
	char goOn;
	int listSize = 0, number, del, nodo, index;

	do {
		printf( "La lista contiene %d nodos. Ingrese el siguiente numero (0 para finalizar)\n", listSize );
		scanf("%d", &number );
		if ( number ) {
			if ( !start ) {
				start = createNode( number, index );
				listSize++;
			} else {
				current = start;
				while ( current->next ) {
					current = current->next;
				}
				current->next = createNode( number, index );
				listSize++;
        current->index=listSize-1;
        //ACA SE REALIZA EL AUMENTO DEL INICE EMPEZANDO DESDE 1 DADO QUE EL ULTIMO NUMERO QUEDA EN 0

			}
			goOn = 1;
		} else {
			goOn = 0;
		}
	} while ( goOn );
	current = start;
	printf( "La lista contiene los numeros: \n" );
	while (current) {
		printf( "%d", current->number);
		printf( current->next ? ", " : "\n" );
		current = current->next;
	}
 
  printf("¿Desea eliminar un nodo? ingrese 1 para si o 0 para finalizar\n");
  scanf("%d", &del);
  if (del==1){
    printf("Ingrese el nodo a eliminar de 1 a %d y 0 para el último\n", listSize-1);
    scanf("%d", &nodo);
    
	
    if(start && nodo == start->index){
      aux=start;
      current=start;
      start=start->next;
      printf("Se eliminó el número %d\n", aux->number);
      free(aux);
      current = start;
      printf( "La nueva lista contiene los numeros: \n" );
      while (current!=NULL) {
        printf( "%d", current->number );
        printf( current->next ? ", " : "\n" );
        current = current->next;
        }
        printf("Programa finalizado con nuevo inicio de lista\n");
    }
    else {
      current=start;
      while(start && nodo != current->index){
        ant=current;
        current=current->next;
        }
      
      if(current)
      {
        ant->next=current->next;
        
      }
      aux=current;
      current = start;
      printf("Se eliminó el número %d\n", aux->number);
      free(aux);
      printf( "La nueva lista contiene los numeros: \n" );
      while (current) {
        printf( "%d", current->number );
        printf( current->next ? ", " : "\n" );
        current = current->next;
        }
        printf("Programa finalizado con normalidad\n");
      }    
  }
  else  {
    printf("Programa finalizado sin eliminar nodos\n");
	current = start;
  }
	while (current) {
		next = current->next;
    free(current);
		current = next;
	}

	return 0;
}```

void eliminarNodo()
{ 	
    int nodo;
    NODE *currnt, *nxt, *del;


    currnt = start;   //setear el currnt
    printf( "La lista contiene los numeros: \n" );
    int i, j;
    for (i =1; i <= listSize; i++) 
    {
    	printf("[%d] ", i);
	printf( "%d", currnt->number );
	printf("\n");
	currnt = currnt->next;
    }
    
    
    printf(" Que posicion desea eliminar?\n");
    scanf("%d", &nodo);

    currnt = start;	//setear el currnt
    if (nodo > listSize)
    {
        printf("\n---\n El nodo que selecciono, no existe!\n\n");
    }
    else if (nodo == 1)
    {
	nxt = currnt->next; 
	start = nxt;
	listSize--;
    }
    else if (nodo > 0)
    {
	j=1;
	printf("Ya entre\n");
	while (currnt != NULL)
	{
	    printf(" Entre en el ciclo\n");
	    if (j == (nodo-1) )
	    {
		del = currnt->next;
		nxt = del->next;
		currnt->next = nxt; 
	    }
	    j++;
	    currnt = currnt->next;    
	}
	listSize--;
    }

    menu();
}

else if (nodo == 1)
    {
	nxt = currnt->next; 
	start = nxt;
	listSize--;
	free(currnt);    //liberar memoria
    }
    else if (nodo > 0)
    {
	j=1;
	printf("Ya entre\n");
	while (currnt != NULL)
	{
	    printf(" Entre en el ciclo\n");
	    if (j == (nodo-1) )
	    {
		del = currnt->next;
		if (del->next)    //Verificar que exista un siguiente
		{    
		    nxt = del->next;
		    currnt->next = nxt;
		}
		else  
		{
		    currnt->next = NULL;
		}
		free(del);     //Liberar memoria
	    }
	    j++;
	    currnt = currnt->next;    
	}
	listSize--;
    }```

Mateo Ferrer

student•

Aurelio ML

Me tomo unas 5 horas, pero ya lo complete. Excelente ejercicio.

David Barreto

Hola amigos, pude hacer el reto y les comparto mi codigo, me sirvio para practicar lo aprendido hasta ahora

Eduardo Sebastián Sandoval Jiménez

Gracias, me ayudo bastante!!!

Ernán Alexander Velásquez Ramírez

Me llevó dos semanas terminar el código del reto. Soy lento pero perseverante, porque lo más importante para mí es aprender. No logré solucionar dos errores que me muestra Valgrind, y si alguno sabe cómo, puede escribirme al correo ernanvr@gmail.com

Código. Permite a) ingresar números para formar lista enlazada, c) ingresar un número cuyos nodos que los contengan serán eliminados.

Víctor Fernández

Alfredo Alexis Alcalá López

Esta es la parte del código que borra los nodos

Miguel Bedoya

Gracias brother por tu aporte, me pareció uno de los más limpios e intuitivos de todos los códigos

Saúl Alejandro Tapia Loya

Este es mi código, pregunta por la posición del nodo a eliminar.

Alejandro Patiño

Paulina Yañez Rubio

Muchísimas gracias, estaba medio perdida.

Delfina Merola Moreschi

Código para eliminar nodos:

Jeffrey Smith

Gracias por tu código :). Me ayudó :). Probándolo,en general corría bien, solo crasheaba cuando se eliminaban todos los números. Y cada que se eliminaba un número que sí estaba, luego ponía como que no estuviese en lista. No pude arreglarlo :( Y cuando usaba vlagrind, crasheaba totalmente. Alguien ayuda? Me gusta este código porque es pequeño.

Gonzalo Godoy

Gerardo Rodriguez Sanchez

Una forma de eliminar los nodos:

Juan Camilo Alvarez Jurado

Mi solución:

Angelo Gabriel Benavidez Chuquilla

Mi solución

Fernando Reséndiz Bautista

Mi solución (mi teclado estaba en ENG)

Mauricio Galvez

Hugo Iván

Dejo mi código por si alguien en el futuro esta atorado y necesita un empujonsito, trate de explicarlo lo mejor posible y dividí las tareas en funciones para que se viera mas ordenado También se aceptan observaciones para mejorar el codigo!

Oscar Jaramillo

😭

Luis Gabriel Delgado Sanchez

Si me costo un poco de trabajo. a ver que opinan...

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

#define R "\033[31m" #define V "\033[32m" #define A "\033[34m" #define F "\033[0m"

void add(); void print(); void delete(); void menu();

typedef struct node { int numero; struct Node *next; } NODE;

NODE *start=NULL; NODE *current; NODE *next;

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

return newNode; }

void add() { int valor; printf(A"Ingresa un valor : "F); scanf("%d",&valor); if (start) { current = start; while (current->next) { current = current->next; } current->next = createNode(valor); } else { start = createNode(valor); } createNode(valor); menu(); }

void print() { current = start; printf(A"la lista contiene :\n"F); while (current) { printf(" %d ", current->numero ); printf(current->next ? "," : "\n"); current = current->next; } sleep(1); menu(); }

// while (current == numero) { // current=current->next; // }

void delete() { current = start; int valor; printf(A "Que valor quieres eliminar : "F); scanf("%d",&valor); if (current->numero == valor) { printf(A "El número a eliminar es el primero \n"F); sleep(1); start=current->next; free(current); } else { printf(A "El número a eliminar no es el primero o no existe \n"F); sleep(1); } menu(); }

void salir() { current = start; while (current == NULL) { next = current->next; free(current); current = next; } printf(R "Saliendo del programna \n"F); sleep(1); }

void menu() { int n; system("clear"); printf(R "############################\n" F); printf(V " Selecciona una opción : \n"F); printf(R "############################\n" F); printf(R "[" F V "0" F R "]" F V" Ingresar número\n" F); printf(R "[" F V "1" F R "]" F V" Imprimir lista\n" F); printf(R "[" F V "2" F R "]" F V" Eliminar número\n" F); printf(R "############################\n" F); printf(R "[" F V "3" F R "]" F V" Salir\n" F); printf(R "############################\n" F); scanf("%d",&n); switch (n) { case 0: add(); break; case 1: print(); break; case 2: delete(); break; case 3: salir(); break; default: printf(A "Opción no valida\n"F); sleep(1); menu(); break; } }

int main(int argc, char const *argv[]) { menu(); return 0; }

Julian Alejandro Archila Caro

Mi solución al reto.

Camilo Gonzalez

Hice el siguiente codigo, me costó mucho entender este tema. Cree un indice (index) para eliminar el nodo y que estuviera dentro de la estructura del nodo, pero tuve que empezarlo en 1 y no en 0 porque el último numero siempre me daba 0 ¿Alguien me explicaria como solucionarlo para poner el indice desde 0? Gracias

Leandro Tenjo

Estuvo pesadísimo! Hice una función para eliminar y puse start como variable global

Había olvidado Liberar Memoria Solo tuve que modificar una parte de Código:

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

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