Dina Mica
Dina Mica
Dina Mica
SISTEMAS COMPUTACIONALES.
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.
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 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.
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.
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.
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.
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.
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
https://chuidiang.org/index.php?title=Gr%C3%A1ficos_Usando_graphics.h