Dina Mica

Descargar como pdf o txt
Descargar como pdf o txt
Está en la página 1de 28

INSTITUTO POLITÉCNICO NACIONAL

ESCUELA SUPERIOR DE CÓMPUTO

SISTEMAS COMPUTACIONALES.

Proyecto segundo parcial.

Título: Programa memoria dinámica lista


doblemente enlazada.

Profesor: De Luna Caballero Roberto.

Alumno: Reyes Espinosa Miguel Angel.

Grupo: 1CM2
ÍNDICE
Introducción ........................................................................................................................................ 3
Doble apuntador. .......................................................................................................................... 19
Desarrollo. ......................................................................................................................................... 22
Estructura de Datos: La Lista Enlazada.......................................................................................... 22
Creación de Nodos: ....................................................................................................................... 22
Uso de la Biblioteca "graphics.h": ................................................................................................. 23
Dinamismo y Asignación de Memoria: ......................................................................................... 23
Paso por Referencia y Doble Apuntador: ...................................................................................... 24
Salida del programa. ..................................................................................................................... 24
Conclusión. ........................................................................................................................................ 27
Bibliografía....................................................................................................................................... 28
Introducción.
El código presentado es un ejemplo claro de cómo la programación no solo
resuelve problemas, sino que también se convierte en una herramienta visual
e interactiva para comprender y manipular estructuras de datos complejas.
Este programa en lenguaje C es un testimonio de cómo la programación
puede ir más allá de la mera resolución de ecuaciones y el procesamiento de
datos abstractos. Aquí, la programación se fusiona con elementos gráficos
para crear una representación tridimensional de una lista enlazada. En esta
introducción, exploraremos cómo este código combina lo artístico y lo
educativo.
El corazón de esta creación es una lista enlazada, una estructura de datos
fundamental en la ciencia de la computación. Sin embargo, este programa va
un paso más allá al no limitarse a administrar esta lista, sino al visualizarla en
una forma de cubo en perspectiva, lo que permite una comprensión más
intuitiva de cómo funcionan los nodos y cómo se relacionan entre sí.
La interacción con el usuario es un elemento crucial. No se limita a una simple
representación estática, sino que permite al usuario agregar y eliminar
números en diferentes ubicaciones de la lista. Esta interactividad, enriquecida
por elementos visuales, agrega una dimensión educativa al programa al
permitir que los usuarios experimenten directamente con la estructura de
datos.
A lo largo de este código, se demuestra la versatilidad de C como lenguaje
de programación y la potencia de la biblioteca de gráficos BGI para crear una
interfaz visual atractiva. También, ilustra cómo la programación puede ser una
herramienta tanto artística como funcional, capaz de dar vida a estructuras
de datos y conceptos abstractos.
En esta introducción, hemos presentado un panorama general de lo que
aborda este código: la conjunción de la programación, la representación
gráfica y la interacción con el usuario. En las secciones posteriores,
exploraremos en detalle las características y funcionalidades de este
programa innovador.
A continuación, se presenta el marco teórico en donde presentamos la
explicación detallada de uno de los conceptos de este programa, su función
general de los mismos y su función específica en este programa para la
comprensión del mismo por medio de la explicación a detalle.
Marco teórico.
Memoria dinámica.
Esta función permite trasladar la información contenida en un bloque de
memoria a otro bloque de mayor tamaño. La función devuelve la dirección del
byte de inicio del bloque y libera la memoria dada al bloque original, para ello
es indispensable el uso de la siguiente libreria para el funcionamiento que
conllevan las funciones de memoria dinámica como Malloc, calloc, etc.

Función Malloc.
Esta función permite buscar un espacio de memoria libre del tamaño deseado
y separarlo, de modo que la dirección del primer byte pueda ser asignada a
un puntero. El prototipo de la esta función se muestra a continuación que al
igual esta función la utilizamos en nuestro programa, para asignarle memoria
dinámica a nuestros nodos y así poder manipularlos en cuanto a posición.

void * malloc (tamaño);


Donde tamaño indica la cantidad de bytes que se desea tenga el bloque de
memoria. El tipo de dato void * indica que la dirección que devuelva la función
no está relacionada con algún tipo de dato, esto se conoce con el nombre
de "Dirección genérica" o "Puntero genérico", por esta razón cuando se
emplee esta función, se deberá aplicar una operación cast al resultado
devuelto por malloc.

Si por alguna razón, la función no pueda ubicar un espacio de memoria del


tamaño deseado o el tamaño solicitado es cero, la función devuelve NULL. A
continuación, podremos visualizar un ejemplo o varios ejemplos para poder
como es que funciona esta función en los programas.
Para comenzar con el marco teórico es indispensable separar el código y
mostrar para que sirve cada concepto, variable y demás cosas utilizadas, es
algo muy indispensable para entender que es lo que haremos e hicimos por
medio del tema de memoria dinamica en el lenguaje de programación c.
Las librerías que ocupamos para la realización del programa siempre
realizando una función muy importante en el código para el funcionamiento
de todos los modos y conceptos de c, y el importante a destacar seria el de
graphics para iniciar los gráficos del modo c, o en nuestro caso el compilador
de c++.

• typedef: typedef es una palabra clave de C que se utiliza para definir


nuevos tipos de datos o para dar un alias a tipos de datos existentes.
En este caso, se está definiendo un nuevo tipo de datos llamado Nodo.
• struct Nodo { ... }: Esto define la estructura de datos Nodo. Dentro de
las llaves { ... } se enumeran los miembros o campos de la estructura,
que son:
• int dato: Un miembro de tipo entero que almacena un valor de datos
asociado con el nodo. Puede ser cualquier tipo de dato que desees
almacenar en el nodo.
• struct Nodo *siguiente: Un miembro que es un puntero a una
estructura Nodo. Este puntero se utiliza para apuntar al siguiente nodo
en la misma fila (hacia la derecha).
• struct Nodo *anterior: Otro miembro que es un puntero a una
estructura Nodo. Este puntero se utiliza para apuntar al nodo anterior
en la misma fila (hacia la izquierda).
• struct Nodo *arriba: Un tercer miembro que es un puntero a una
estructura Nodo. Este puntero se utiliza para apuntar al nodo en la fila
superior (hacia arriba).
• struct Nodo *abajo: El último miembro, que es un puntero a una
estructura Nodo. Este puntero se utiliza para apuntar al nodo en la fila
inferior (hacia abajo).
• Nodo;: La declaración final Nodo; asigna un alias o nombre de tipo
Nodo a esta estructura. Esto permite que en el código puedas declarar
variables o punteros de tipo Nodo en lugar de usar struct Nodo cada
vez que necesites referenciar esta estructura
En esta parte declaramos los prototipos de las funcione son como su nombre
lo indica de relación con agregar nodos, eliminar nodos, y dibujar los
cuadrados en el modo gráfico, además de variable globales para la utilización
de ciclos, y variable tipo char para poder representar número en el modo
gráfico por medio de funciones que veremos y detallaremos más adelante en
el programa.
En la parte del main tenemos definiciones que a lo largo del código nos
sirvieron de mucho, como por ejemplo el menu que sirve para orientar al
usuario que es lo que quiere realizar a lo largo del programa o en la lista
enlazada, a continuación se presentara o definirá cada función a más detalle.
• Nodo *cabeza = NULL;: En esta línea, se declara un puntero cabeza
de tipo Nodo que se inicializa como NULL. Este puntero se utilizará
para mantener el inicio de la lista enlazada.
• agregarElementosIniciales(&cabeza);: Se llama a la función
agregarElementosIniciales y se le pasa una referencia al puntero
cabeza. Esta función se utiliza para agregar elementos iniciales a la
lista enlazada. Como resultado, la lista tendrá algunos elementos
predeterminados en su inicio.
• int gd = DETECT, gm;: Se declaran las variables gd y gm que se
utilizan para configurar la ventana gráfica. DETECT es una constante
predefinida en la biblioteca "graphics.h" que generalmente se utiliza
para detectar automáticamente la configuración de gráficos del
sistema.
• initgraph(&gd, &gm, "C:\\Turboc3\\BGI");: Se llama a la función
initgraph para inicializar la ventana gráfica utilizando los valores de gd
y gm. El tercer argumento es la ubicación del controlador BGI que se
utilizará para la representación gráfica. Esto es específico de Turbo
C++ y se utiliza para crear una ventana gráfica en la que se mostrará
la lista enlazada.
• while (1) { ... }: Esto inicia un bucle while infinito que presenta un menú
interactivo al usuario. El bucle se ejecutará indefinidamente hasta que
el usuario elija salir del programa.
• El menú interactivo muestra varias opciones al usuario, como agregar
elementos al inicio, insertar elementos en una posición, agregar
elementos al final, mostrar la lista, invertir la lista y salir del programa.
• scanf("%d", &opcion);: Se utiliza scanf para leer la opción
seleccionada por el usuario y almacenarla en la variable opcion.
• switch (opcion) { ... }: Se utiliza una estructura switch para realizar
una acción basada en la opción seleccionada por el usuario. Las
diferentes opciones en el menú se corresponden con los casos en el
switch.
• En cada caso del switch, se solicita al usuario que proporcione
información adicional (como el valor a agregar, la posición de inserción,
etc.) y se llama a las funciones correspondientes (por ejemplo,
agregarInicio, insertarElemento, agregarFinal,
mostrarDatosEnVentana, invertirLista, liberarLista, etc.) para realizar la
acción deseada en la lista enlazada. El bucle se repetirá después de
completar la acción hasta que el usuario seleccione la opción "Salir",
momento en el que el programa liberará la memoria asignada para la
lista y cerrará la ventana gráfica antes de finalizar.
Ahora veremos las funciones una a una para ver cmo se realizarón los
enlaces previamente mencionados.
La función agregarElementosIniciales se encarga de crear una serie de
nodos al principio de la lista. Estos nodos se crean en filas y columnas, y cada
nodo contiene un valor que es igual al número de fila multiplicado por el
número de nodos por fila, más un valor de columna. Esto asegura que los
valores de los nodos se incrementen secuencialmente.
El ciclo for itera a través de las filas, desde 0 hasta filas - 1. El ciclo for interno
itera a través de las columnas, desde 1 hasta nodosPorFila. Dentro del ciclo
interno, se llama a la función agregarInicio para agregar un nuevo nodo al
inicio de la lista enlazada.
La función agregarInicio crea un nuevo nodo y le asigna el valor
proporcionado como argumento. Luego, enlaza este nuevo nodo con el nodo
que actualmente es el primero de la lista (*cabeza). El nuevo nodo se
convierte en el nuevo primer nodo (*cabeza), y su enlace siguiente.
Esta función nos permite agregar un nodo en la posición que deseemos o el
usuario desee, para ello implementamos ciertas condiciones que se explican
a continuación.
Se verifica si la posición proporcionada (posición) es menor o igual a 0. Si es
así, se muestra un mensaje de error y se retorna, ya que la posición debe ser
mayor que 0 para que tenga sentido.
Se crea un nuevo nodo (nuevoNodo) y se le asigna el valor proporcionado
(valor). Se inicializan los enlaces arriba y abajo como NULL, ya que no se
sabe si el nuevo nodo tendrá enlaces en estas direcciones.
Se verifica si la posición deseada es 1, lo que significa que el nuevo nodo
debe ser insertado al principio de la lista. Si es así:
Se establece el enlace siguiente del nuevo nodo para que apunte al actual
primer nodo de la lista (*cabeza).
Se establece el enlace anterior del nuevo nodo en NULL, ya que es el nuevo
primer nodo.
Si la lista no estaba vacía (es decir, *cabeza no era NULL), se agrega un
enlace hacia arriba desde el primer nodo de la lista al nuevo nodo. Además,
se actualiza el enlace anterior del primer nodo para que apunte al nuevo nodo,
ya que ahora el nuevo nodo es el primer elemento de la lista.
Finalmente, se actualiza *cabeza para que sea el nuevo nodo, ya que ahora
es el primer elemento de la lista.
Si la posición no es 1, significa que el nuevo nodo debe insertarse en algún
lugar después del primer nodo. Un ciclo while se utiliza para recorrer la lista
hasta llegar a la posición anterior a la posición deseada o hasta el final de la
lista. Mientras se recorre la lista:
Se incrementa el contador i para rastrear la posición actual.
Si se llega al final de la lista sin encontrar la posición deseada, se muestra un
mensaje de error y se libera la memoria del nuevo nodo. Luego, la función
termina.
Si se encuentra la posición deseada:
Se actualizan los enlaces siguiente y anterior del nuevo nodo para que estén
conectados apropiadamente en la posición deseada.
Si el nodo siguiente al nuevo nodo (después de la inserción) no es NULL, se
agrega un enlace hacia arriba desde ese nodo al nuevo nodo. También, se
actualiza el enlace anterior de ese nodo siguiente para que apunte al nuevo
nodo, ya que el nuevo nodo se ha insertado después de él.

agregarEnlaceArriba:
Esta función recibe dos parámetros: nodoActual y nodoArriba, que
representan los nodos que se conectarán en dirección vertical.
Primero, verifica si ambos nodos (nodoActual y nodoArriba) son diferentes de
NULL para asegurarse de que existen antes de establecer un enlace.
Luego, en el nodo nodoActual, se establece el puntero arriba para que apunte
al nodo nodoArriba. Esto crea un enlace desde el nodo actual hacia arriba,
permitiendo acceder al nodo superior desde el nodo actual.
En el nodo nodoArriba, se establece el puntero abajo para que apunte al nodo
nodoActual. Esto crea un enlace desde el nodo superior hacia abajo,
permitiendo acceder al nodo actual desde el nodo superior. De esta manera,
los dos nodos quedan enlazados verticalmente.
agregarEnlaceAbajo:
Al igual que agregarEnlaceArriba, esta función recibe dos parámetros:
nodoActual y nodoAbajo, que representan los nodos que se conectarán en
dirección vertical.
Comienza verificando si ambos nodos (nodoActual y nodoAbajo) son
diferentes de NULL para asegurarse de que existen antes de establecer un
enlace.
Luego, en el nodo nodoActual, se establece el puntero abajo para que apunte
al nodo nodoAbajo. Esto crea un enlace desde el nodo actual hacia abajo,
permitiendo acceder al nodo inferior desde el nodo actual.
En el nodo nodoAbajo, se establece el puntero arriba para que apunte al nodo
nodoActual. Esto crea un enlace desde el nodo inferior hacia arriba,
permitiendo acceder al nodo actual desde el nodo inferior. De esta manera,
los dos nodos quedan enlazados verticalmente.

En la función invertirLista, se invierte la lista enlazada, y al mismo tiempo, se


intercambian los enlaces tanto en dirección vertical como horizontal entre
nodos. A continuación, se explica el funcionamiento de esta función:
Se comienza declarando dos punteros actual y temp, ambos inicializados al
comienzo de la lista (*cabeza).
Luego, se inicia un bucle while que recorre la lista desde el principio hasta el
final. Durante este recorrido, se lleva a cabo la inversión de la lista y el
intercambio de enlaces.
En cada iteración del bucle:
Se intercambian los enlaces arriba y abajo del nodo actual. Esto significa que
si un nodo apuntaba hacia arriba, ahora apuntará hacia abajo y viceversa.
Esto invierte la dirección vertical de los enlaces en la lista.
Luego, se intercambian los enlaces anterior y siguiente del nodo actual. Esto
significa que si un nodo apuntaba al nodo anterior, ahora apuntará al nodo
siguiente y viceversa. Esto invierte la dirección horizontal de los enlaces en
la lista.
El puntero actual se actualiza para apuntar al nodo anterior en la lista. Esto
permite que el bucle continúe invirtiendo los enlaces de nodo en nodo hasta
que llegue al final de la lista.
Finalmente, se verifica si temp (el último nodo original de la lista antes de la
inversión) es diferente de NULL. Si es diferente de NULL, se actualiza el
puntero cabeza para que apunte al nuevo comienzo de la lista invertida.

LISTA ENLAZADA SIMPLE.


Este fragmento de código se encuentra dentro de un bucle while (1), que crea
un bucle infinito para mantener la aplicación en ejecución y permitir al usuario
interactuar con la lista enlazada y ver los cambios en la ventana de gráficos.
struct Nodo* temp = head; Se declara un puntero temp que apunta al mismo
nodo que el puntero head. Este puntero temp se utilizará para recorrer la lista
enlazada sin modificar la posición del puntero head.
x2 = x; Se inicializa la variable x2 con el valor de x, que representa la posición
en el eje X donde se dibujarán los cuadrados que representan los nodos en
la lista enlazada.
El bucle while (¡temp! = NULL) recorre la lista enlazada comenzando desde
el nodo apuntado por head y continúa hasta que llega al final de la lista
(cuando temp es NULL).
dibujarCuadrado (x2, y, lado, temp->numero, temp->siguiente); En cada
iteración del bucle, se llama a la función dibujarCuadrado para dibujar un
cuadrado en la posición (x2, y) que representa un nodo en la lista. Los
argumentos son el valor del nodo (temp->numero) y el puntero al siguiente
nodo (temp->siguiente).
x2 += 2 * lado; Se actualiza la posición en el eje X (x2) para que el siguiente
cuadrado se dibuje al lado del anterior. Se multiplica por 2 * lado para dejar
un espacio entre los cuadrados.
temp = temp->siguiente; El puntero temp se mueve al siguiente nodo en la
lista, lo que permite iterar a través de todos los nodos de la lista.
Este bucle permite dibujar gráficamente la lista enlazada en la ventana de
gráficos. Cada nodo se representa como un cuadrado en la posición (x2, y),
y las flechas que unen los cuadrados indican la conexión entre los nodos en
la lista enlazada.

En esta parte del código podemos observar que dentro del mismo bucle que
comentamos anteriormente se encnutra un menú que le permite al usuario
elegir que es lo que desea hacer en la lista enlazada previamente definida, y
despues veremos como funciona cada condicional ahí por el momento vemos
que, si elige la opción 1, esta indica otro mini menu, para saber que posición
colocar el nuevo número.
En esta parte del código identificamos que son las condicionales para la
ejecución dependiendo la opción de los menús que haya elegido el usuario,
y en las condicionales se llaman a las funciones dependiendo cual se vaya a
utilizar para realizar dicha condicional.

Este fragmento de código se encuentra al final del programa y se encarga de


liberar la memoria asignada dinámicamente para los nodos de la lista
enlazada antes de cerrar el programa. Aquí se detalla su funcionamiento:
while (¡head! = NULL): Este bucle while se ejecuta mientras el puntero head
no sea NULL, lo que significa que todavía hay nodos en la lista enlazada por
liberar.
struct Nodo* temp = head; Se declara un puntero temporal temp que apunta
al mismo nodo que el puntero head. Esto se hace para evitar perder la
referencia al nodo que se va a liberar.
head = head->siguiente; Se actualiza el puntero head para que apunte al
siguiente nodo en la lista enlazada. Esto mueve el puntero head hacia
adelante en la lista.
free (temp); Se utiliza la función free para liberar la memoria asignada
dinámicamente para el nodo al que apunta el puntero temp. Esto es esencial
para evitar pérdidas de memoria y posibles fugas de memoria.
El bucle continúa hasta que head se vuelve NULL, lo que significa que se ha
recorrido y liberado toda la lista enlazada.
Finalmente, el programa devuelve 0 como un indicador de que se ejecutó sin
errores y se cierra.
En resumen, este fragmento de código se encarga de liberar la memoria de
todos los nodos en la lista enlazada antes de que el programa termine, lo que
es una buena práctica para administrar adecuadamente la memoria dinámica
asignada.

Esta parte del código se refiere a dibujar los cuadros que contienen al número
de la lista enlazada, al igual todo lo que tiene que ver con el diseño, como lo
son las fechas, líneas, cuadrados, y demás para una buena visualización
gráfica del programa gráfico de la lista enlazada.
struct Nodo* nuevoNodo = (struct Nodo*) malloc (sizeof (struct Nodo));
Se crea un nuevo nodo asignando dinámicamente memoria para él utilizando
la función malloc. El tamaño asignado es igual al tamaño de una estructura
Nodo. Si la asignación de memoria falla, se muestra un mensaje de error y
se devuelve.
nuevoNodo->numero = num; El valor pasado como argumento num se
asigna al miembro número del nuevo nodo.
Luego, se verifica si se debe agregar el nodo al principio de la lista (cuando
posición es igual a 1) o en otro lugar de la lista (cuando posición es diferente
de 1).
Si posición es igual a 1, se ajusta el puntero siguiente del nuevo nodo para
que apunte al mismo nodo al que apunta *head, y luego se actualiza *head
para que apunte al nuevo nodo. Esto coloca el nuevo nodo al principio de la
lista.
Si posición no es igual a 1, se utiliza un bucle while para recorrer la lista hasta
la posición deseada (posición - 1). En este punto, temp apunta al nodo
anterior al lugar donde se debe insertar el nuevo nodo. Se verifica si se llegó
al final de la lista (temp es NULL) o si la posición especificada no es válida
(por ejemplo, si la lista tiene menos nodos que la posición especificada). En
ambos casos, se muestra un mensaje de error, se libera la memoria del nuevo
nodo y se devuelve.
Si la posición es válida, el nuevo nodo se inserta en la lista. El puntero
siguiente del nuevo nodo se ajusta para que apunte al nodo siguiente en la
lista, y el puntero siguiente del nodo anterior (temp) se ajusta para que apunte
al nuevo nodo. Esto conecta el nuevo nodo en la posición deseada de la lista.
En resumen, esta función permite agregar un nuevo nodo a una lista enlazada
en una posición específica, ya sea al principio, en el medio o al final de la
lista, asegurándose de que la memoria se asigne adecuadamente y de que
la lista se actualice correctamente. También maneja casos de error si la
asignación de memoria falla o si la posición especificada no es válida.

De la misma manera de la función anterior en esta elimínanos nodos, es decir


que si el usuario teclea un número que se encuentre en la lista, este se elimina
si así lo desea, recorriendo la lista como se muestra, y si no existe muestra
un mensaje que la opción no es válida.
Doble apuntador.
Las funciones que toman un doble apuntador (puntero a puntero) como
argumento son funciones que operan sobre datos mediante un paso por
referencia. En este caso, el doble apuntador se utiliza para permitir que la
función modifique la dirección de memoria a la que apunta el puntero original.
Estas funciones son, por lo tanto, funciones por referencia.
Cuando se trabaja con funciones por referencia, los cambios realizados en
los datos dentro de la función se reflejan en los datos originales fuera de la
función. En el caso de la lista enlazada, esto significa que la función puede
modificar directamente la estructura de la lista enlazada, como agregar o
eliminar nodos, y estos cambios se mantendrán en la lista original fuera de la
función.

Por otro lado, las funciones por valor son aquellas en las que los argumentos
se pasan por valor, lo que significa que se pasa una copia de los datos
originales a la función, y cualquier modificación realizada dentro de la función
no afectará a los datos originales fuera de la función.

Ejemplo 1: Lista simple enlazada.


Este es un ejemplo muy simple de lista enlazada, en donde podemos
observar la creación de nodos definidos por una estructura que contiene dos
datos, despues a cada nodo le asignamos memoria dinamica con la función
malloc a cada nodo para despues asignarle un valor entero, en donde cada
nodo apunta a su dato, despues enlazamos a los nodos para que cada uno
apunte al siguiente y el último elemento apunte a NULL.

En al anterior esquema observamos la funcionalidad de nuestro programa,


en donde el apuntador inicio apunta a nuestro primer dato, y ese apunta al
siguiente, de esa forma hasta llegar a NULL.
Ejemplo 2.
En este ejemplo, hemos declarado un puntero a un entero llamado numero y
luego utilizamos malloc para asignar memoria para un solo entero
(sizeof(int)). Luego, asignamos un valor al entero y lo imprimimos.
Finalmente, liberamos la memoria asignada con free.

En esta tabla la variable "numero" es un puntero a un entero que apunta a


una dirección de memoria específica (0x7f4d12b03650). La dirección de
memoria 0x7f4d12b03650 contiene el valor 42, que es el valor asignado al
entero al que apunta el puntero.
Esta tabla representa el estado de las variables en memoria después de
asignar memoria dinámica para un entero, asignarle el valor 42 y antes de
liberar la memoria. Después de la liberación de la memoria, el puntero
"numero" aún existiría, pero su contenido (la dirección de memoria) no sería
válida.
Ejemplo 3.
En este ejemplo, hemos declarado un puntero arreglo y luego hemos utilizado
malloc para asignar memoria para un arreglo de enteros con 5 elementos (n
* sizeof(int)). Luego, inicializamos el arreglo con valores y lo imprimimos.
Finalmente, liberamos la memoria asignada con free
Una representación de como se podría visualizar de manera lógica sería la
siguiente.

Desarrollo.
Este reporte detallado abordará la implementación de una lista enlazada en
el lenguaje de programación C, que se ha realizado en conjunto con gráficos
utilizando la biblioteca "graphics. H". La lista enlazada es una estructura de
datos fundamental que se utiliza comúnmente en programación para
gestionar y organizar datos. En este caso, la lista enlazada se ha utilizado
para crear un programa interactivo que permite a los usuarios agregar,
eliminar y visualizar nodos con representaciones gráficas.

Estructura de Datos: La Lista Enlazada


Una lista enlazada es una estructura de datos lineal compuesta por nodos,
donde cada nodo contiene dos elementos: un valor de datos y un puntero al
siguiente nodo en la lista. En nuestro caso, hemos creado una estructura
llamada "Nodo" que contiene un entero llamado "numero" y un puntero a la
siguiente estructura "Nodo".

Creación de Nodos:
Para crear nodos y gestionar la lista enlazada, se han implementado tres
funciones principales las cuales fueron de mucha ayuda para realizar y
cumplir el objetivo de nuestro programa, y tambien los nodos ya que estos
eran lo principal en nuestro sistema.:
agregarNodo: Esta función se utiliza para agregar un nuevo nodo a la lista
enlazada. Puede agregar un nodo al principio, en medio o al final de la lista
según las preferencias del usuario.
eliminarNodo: Permite eliminar un nodo de la lista enlazada. Al igual que con
la función agregarNodo, se puede especificar la posición del nodo que se
desea eliminar.
dibujarCuadrado: Esta función se encarga de dibujar un cuadrado en la
ventana gráfica, representando un nodo de la lista enlazada. También
muestra el valor del nodo en el centro del cuadrado.
Interacción con el Usuario:
El programa interactúa con el usuario proporcionando un menú que permite
realizar diversas acciones:
Agregar número: El usuario puede agregar un nuevo número a la lista
enlazada. Puede elegir si desea agregarlo al principio, en medio o al final de
la lista.
Eliminar número: Permite al usuario eliminar un número de la lista enlazada
especificando su posición.
Finalizar: Esta opción permite al usuario salir del programa y cerrar la ventana
gráfica.

Uso de la Biblioteca "graphics.h":


La biblioteca "graphics.h" se utiliza para crear una interfaz gráfica simple que
muestra los nodos de la lista enlazada y permite al usuario interactuar con
ellos. Esto se logra dibujando cuadrados en la ventana gráfica para
representar los nodos y utilizando flechas para indicar las relaciones entre los
nodos.

Dinamismo y Asignación de Memoria:


El código presentado destaca el concepto de asignación de memoria
dinámica. En lugar de reservar un espacio estático para los datos, la memoria
se asigna a medida que se agregan elementos a la lista enlazada. Esto es
especialmente útil cuando la cantidad de datos es desconocida o variable. La
función malloc se utiliza para asignar memoria para cada nodo, y su dirección
se almacena en el puntero del nodo.
Paso por Referencia y Doble Apuntador:
Un aspecto importante del código es el uso de funciones que operan sobre la
lista enlazada mediante el uso de dobles apuntadores. Los dobles
apuntadores se utilizan para permitir que las funciones modifiquen
directamente la dirección de memoria a la que apunta el puntero original. Esto
se conoce como paso por referencia, y es fundamental para que las funciones
puedan agregar o eliminar nodos de la lista enlazada y reflejar esos cambios
en la lista original fuera de la función.
Se puede recalcar el uso de la modulación para realizar este programa, donde
siempre es muy importante para todo, ya que esta nos permite llevar un orden
y ver un código más limpio y con mejor visualización para tender con que
estamos trabajando, o si existe una mejora poder directamente ir a la función
requerida y poder modificarla dependiendo de lo que queramos realizar y si
no pues el orden siempre será fundamental en cualquier aspecto de
programación además de una buena o buen análisis antes de empezar a
teclear en la computadora.

Salida del programa.


El menú con el que se había mencionado antes, además de un pequeño
ejemplo de como el usuario lo puede manipular y hacer lo que el elija
dependiendo las opciones que se muestran.

Y por último la salida de modo gráfico que muestra el resultado final, de la


lista enlaza que se puede manipular por medio del menú que previamente
visualizamos y las opciones que tiene, en este se muestre como se apuntan,
desde head, la lista hasta null, igualmente podemos observar un poco de
forma lógica la siguiente imagen de cómo funcionan las listas enlazadas en
este programa.
Y si queremos agregar un nuevo nodo al principio nuestro apuntador cabeza
estaría apuntado al nuevo nodo, y el nuevo nodo al primer nodo, quedando
de la siguiente manera.

Si el usuario desea agregar un nodo en una posición especifica que el elija,


por ejemplo en la posición 3, el nodo 2 apuntaría al nuevo nodo, y el nuevo
nodo apuntaría al nodo 4 que antes era el 3, y se vería representado de la
siguiente manera.

Salida del programa de la lista doblemente enlazada de manera gráfica que


representa los enlaces de izquierda a derecha y de arriba y abajo.
Esa parte representa 25 nodos, en donde tenemos un menú interactivo que
el usuario puede manipular, en donde las opciones o la opción que destaca
para verificar los enlaces que si funcionan es la de invertir lista.

Conclusión.
En resumen, la implementación de una lista enlazada en el código
proporcionado es una introducción sólida a las estructuras de datos, la
asignación de memoria dinámica y la programación en C. La lista enlazada
es un concepto fundamental en informática y se aplica ampliamente en la
resolución de problemas y en el desarrollo de software. La capacidad de
manipular datos de manera eficiente y dinámica la convierte en una elección
esencial en la programación, y la visualización gráfica añade un elemento
educativo y práctico a esta implementación.
En última instancia, este código demuestra que, con una comprensión sólida
de las estructuras de datos y las técnicas de programación, es posible crear
aplicaciones interactivas y funcionales que son útiles en una variedad de
contextos. La lista enlazada es un componente clave de este proceso y una
habilidad importante para cualquier programador.
El concepto de asignación de memoria dinámica y la gestión de punteros es
un área crítica en la programación, y esta implementación no escatima en
ejemplos prácticos. Los desarrolladores pueden aprender cómo se maneja la
memoria dinámica y cómo se crean nodos para formar una lista enlazada.
Además, las opciones de agregar y eliminar elementos brindan una visión
clara de cómo se manipulan los punteros para modificar la estructura de la
lista.
En resumen, este código no solo es una herramienta técnica para trabajar
con listas enlazadas, sino que también es un recurso educativo y una
manifestación impresionante de cómo la programación y las estructuras de
datos pueden converger para resolver problemas y crear soluciones
interactivas. Las listas enlazadas son una parte esencial del arsenal del
programador, y este código proporciona una base sólida para comprender su
funcionamiento y aplicación en proyectos más amplios de desarrollo de
software y gestión de datos.

Bibliografía.
Sierra, F. J. C. (1991). Enciclopedia del Lenguaje C. Enciclo.

https://dialnet.unirioja.es/servlet/libro codigo=373235

Delgado, M. L. P. (2004). Programación en Lenguaje C. En Ediciones Universidad

de Salamanca eBooks. https://eusal.es/eusal/catalog/book/978-84-7800-540-6

Moisset, D. (s. f.). C ya. https://www.tutorialesprogramacionya.com/cya/

Gr Ficos en c. (s. f.). https://electrorichard.tripod.com/Graficos.htm

ChuWiki. (2016). Gráficos Usando graphics.h - ChuWiki. ChuWiki.

https://chuidiang.org/index.php?title=Gr%C3%A1ficos_Usando_graphics.h

También podría gustarte