1. Clases Referenciadas y
Listas Enlazadas en C#
Profesor: Emmanuel Hidalgo
ALUMNAS:
Universidad Americana
Natalie Cedeño Araya
María José Casco Rojas
Rebeca Coto Sánchez
Viviana Ramírez Gamboa
2. Contenido
INTRODUCCIÓN................................................................................................................................... 3
ESTRUCTUCTURA DE DATOS ............................................................................................................... 5
Matrices: ..................................................................................................................................... 6
1. Campo: .................................................................................................................................... 7
o Nombre: .............................................................................................................................. 7
o Tipo:..................................................................................................................................... 7
o Tamaño:............................................................................................................................... 7
2. Registros:................................................................................................................................. 7
o Registro lógico:.................................................................................................................... 7
o Registro físico:..................................................................................................................... 7
3. Archivos :................................................................................................................................. 8
o Creación: ............................................................................................................................. 8
o Apertura: ............................................................................................................................. 8
o Cierre:.................................................................................................................................. 8
o Lectura / Consulta:.............................................................................................................. 8
o Fin de Archivo:..................................................................................................................... 8
o Actualización: ...................................................................................................................... 8
o Destrucción : ....................................................................................................................... 9
4. Base de Datos:......................................................................................................................... 9
CLASES AUTO-REFERENCIADAS.............................................................................................. 9
LISTAS ENLAZADAS............................................................................................................................ 11
Recorrido:.......................................................................................................................... 12
Inserción:........................................................................................................................... 12
Borrado:............................................................................................................................. 13
Búsqueda........................................................................................................................... 14
Elementos de las listas ................................................................................................................. 14
1. Nodo.................................................................................................................................. 14
2. Enlace o dirección de la lista ............................................................................................. 14
3. Dato: (esta dentro de un nodo, si el nodo esta vacio su dato es nulo (NULL))..... 14
Ventajas de usar listas................................................................................................................... 14
3. Desventaja de usar listas:.............................................................................................................. 14
Representación de listas enlazadas en memoria.......................................................................... 14
Tipos de listas más comunes:........................................................................................................ 15
Listas Enlazadas Simples:.......................................................................................................... 15
Listas enlazadas Dobles:............................................................................................................ 15
Listas Circulares:........................................................................................................................ 16
o Listas enlazadas simples circulares ................................................................................... 16
o Listas enlazadas doblemente circulares............................................................................ 17
Nodos centinelas........................................................................................................................ 17
Aplicaciones de las listas enlazadas: ............................................................................................. 18
Historia de las listas:...................................................................................................................... 18
CONCLUSIÓN..................................................................................................................................... 21
BIBLIOGRAFIA.................................................................................................................................... 22
Fuentes Primarias:..................................................................................................................... 22
Fuentes Bibliográficas ............................................................................................................... 22
ANEXOS ............................................................................................................................................. 23
CODIGO PARA CORRER UNA LISTA DOBLEMENTE ENLAZADA.................................................. 23
4. INTRODUCCIÓN
Una estructura de datos es una manera de almacenar y organizar datos para
facilitar el acceso y modificaciones; visto así podemos definir una estructura como
un grupo de variables las cuales pueden ser de diferentes tipos sostenidas o
mantenidas juntas en una sola unidad, llamada estructura.
De lo mencionado anteriormente, podemos definir que las estructuras de datos
como una colección de datos que se caracterizan por su organización y las
operaciones que se definen en ella; algunas de las más usadas son los arrays, sin
embargo este tipo de estructura tienen una importante limitación: no pueden
cambiar de tamaño durante la ejecución, pues están compuestos por un
determinado número de elementos, número que se decide en la fase de diseño,
antes de que el programa ejecutable sea creado.
Pese a lo descrito en el párrafo anterior, en muchas ocasiones se necesitan
estructuras que puedan cambiar de tamaño durante la ejecución del programa,
pues si definimos en un programa una variable estática estamos fijado
previamente cual va a ser su espacio en memoria y cuáles van a ser los posibles
valores que puede tomar a lo largo de la ejecución del programa; existen
problemas complejos que se resuelven más eficazmente mediante la utilización de
variables que cambien dinámicamente la cantidad o el tipo de datos que pueden
contener; este tipo de estructuras de datos se denomina estructuras dinámicas.
Visto así, en el presente trabajo se abordará el tema de estructuras dinámicas,
enfatizando principalmente en las clases auto-referencias y tipos de listas (listas
enlazadas: Lista Enlazadas Simples, Listas Doblemente Enlazadas, Listas
Enlazadas Circulares y Listas Enlazadas Doblemente Circulares); definidas estas
últimas como una secuencia de nodos, en los que se guardan campos de datos y
una o dos referencias (punteros) al nodo anterior y/o posterior. El principal
beneficio de las listas enlazadas respecto a los arrays convencionales,
5. mencionados anteriormente, es que el orden de los elementos enlazados puede
ser diferente al orden de almacenamiento en la memoria o el disco, permitiendo
que el orden de recorrido de la lista sea diferente al de almacenamiento.
6. ESTRUCTUCTURA DE DATOS
Una estructura de datos es una forma de organizar un conjunto de
datos elementales con el objetivo de facilitar su manipulación. Un dato elemental
es la mínima información que se tiene en un sistema.
Una estructura de datos define la organización e interrelación de estos y un
conjunto de operaciones que se pueden realizar sobre ellos. Las operaciones
básicas son:
Alta, adicionar un nuevo valor a la estructura.
Baja, borrar un valor de la estructura.
Búsqueda, encontrar un determinado valor en la estructura para realizar una
operación con este valor, en forma secuencial o binario (siempre y cuando los
datos estén ordenados).
Otras operaciones que se pueden realizar son:
Ordenamiento, de los elementos pertenecientes a la estructura.
Apareo, dadas dos estructuras originar una nueva ordenada y que contenga a
las apareadas.
Cada estructura ofrece ventajas y desventajas en relación a la simplicidad y
eficiencia para la realización de cada operación. De esta forma, la elección de la
estructura de datos apropiada para cada problema depende de factores como la
frecuencia y el orden en que se realiza cada operación sobre los datos.
Existen estructuras de datos dinámicas (LISTAS ENLAZADAS , pilas, colas,
arboles) y Estáticas.
Las estructuras de datos estáticas más comunes son:
7. Matrices: se define como una tabla de tablas, o vector de vectores, es decir, es
aquella en la cual uno de sus elementos es, a su vez, una tabla unidimensional.
Vectores: es una zona de almacenamiento continuo, que contiene una serie de
elementos del mismo tipo, los elementos de la matriz. Desde el punto de vista
lógico una matriz se puede ver como un conjunto de elementos ordenados en fila
(o filas y columnas si tuviera dos dimensiones).
Existe una jerarquía básica a la hora de utilizar las estructuras de datos: La
Jerarquía básica de una Estructura de Datos es la siguiente:
12
Fila 1
Fila 2
Fila 3
Columna 1 Columna 2 Columna 3 Columna 4
Base de datos
Archivo Archivo Archivo
Registro Registro Registro Registro
Campo Campo Campo CampoCampo
Caracter Caracter Caracter CaracterCaracter
8. 1. Campo: Un campo es un conjunto de caracteres capaz de suministrar
una determinada información referida a un concepto. Un campo es un
elemento de datos elementales tales como nombre y apellido, numero de
documento, domicilio, etc. Un campo es la unidad mínima de información
de un registro. Al igual que en las variables, al definir un campo hay que
indicar claramente sus tres características:
o Nombre: Nombre que identifica a ese conjunto de caracteres
o Tipo: Tipo de caracteres que puede contener (alfabético, entero, u
otro)
o Tamaño: Cantidad de caracteres que puede contener
2. Registros: Un registro es un conjunto de campos referentes a una
entidad en particular y constituyen una unidad para su proceso. Un ejemplo
de un registro puede ser la información de un determinado alumno
universitario, que contiene los campos: libreta universitaria, apellido y
nombre, número de documento, domicilio, fecha de nacimiento, entre otros
campos. Existen dos tipos de registro:
o Registro lógico: Se denomina registro lógico al conjunto de campos
o datos referente a un mismo objeto y constituyen una unidad para
su proceso. Son los registros organizados en campos
o Registro físico: Registro físico es un conjunto de registros lógicos
que constituyen la unidad de transferencia en una sola operación de
entrada / salida (para transferencias entre las unidades de E/S o
dispositivos de almacenamiento, y la memoria principal).
9. 3. Archivos :Es el conjunto de registros homogéneos referidos a objetos
de la misma naturaleza o del mismo tipo, almacenados en un soporte
externo, que presenta entre sí una relación lógica y que pueden ser
consultados individualmente de forma iterativa o sistemática. Para la
formación y destruccion de un archivo existen las siguientes funciones:
o Creación: Se crea el archivo recolectando o “archivando” una
serie de registros.
o Apertura: Abrir un archivo significa dejarlo dispuesto para
ser utilizado. Todos los archivos que se ocupan en un
programa deben ser abiertos previamente a su uso.
o Cierre: La finalidad de cierre de los archivos radica en
permitir al usuario detener el uso de ese archivo, dejarlo
inaccesible.
o Lectura / Consulta: Es la operación que nos permite
acceder al archivo de datos para conocer la información
alojada en uno, varios o todos los registros del archivo.
o Fin de Archivo: Toda instrucción de ingreso de datos, ya
sea desde teclado o desde un dispositivo magnético, requiere
una condición de fin de ingreso de los datos
o Actualización: La actualización de un archivo supone las
siguientes operaciones:
i. Añadir registros
ii. Modificar registros ya existentes
iii. Borrar registros
libretauniversitaria Apellidoynombre númerodedocumento Domicilio Fechadenacimiento
10. o Destrucción : La operación de destrucción o borrado realiza
la supresión del archivo en el soporte o dispositivo, dejando
este espacio que ocupaba anteriormente disponible
4. Base de Datos: Es una colección de archivos relacionados
lógicamente, que se estructura en diferentes formas para reducir
duplicaciones y proporcionar un mejor acceso a los datos. Constituye el
nivel más alto en la jerarquía de organización de los datos, siendo el nivel
más bajo el carácter. Así una base de datos de una universidad podría
contener archivos de estudiantes, profesores, inventarios, libros, etc. La
figura presenta gráficamente la estructura jerárquica en base de datos.
CLASES AUTO-REFERENCIADAS
Las estructuras básicas como structs arrays tienen una importante limitación: no
pueden cambiar de tamaño durante la ejecución. Los arrays están compuestos por
un determinado número de elementos, número que se decide en la fase de
diseño, antes de que el programa ejecutable sea creado.
Por lo mencionado anteriormente, en muchas ocasiones se necesitan estructuras
que puedan cambiar de tamaño durante la ejecución del programa; las estructuras
dinámicas, en este sentido nos permiten crear estructuras de datos que se
adapten a las necesidades que requiere los programas elaborados
Las estructuras de datos están compuestas de otras pequeñas estructuras a las
que llamaremos nodos o elementos, que agrupan los datos con los que trabajará
nuestro programa y además uno o más punteros auto-referenciadas, es decir,
punteros a objetos del mismo tipo nodo.
Para que las estructuras listas sean implementadas, necesitan de las clases auto-
referenciadas ; las cuales están estructuradas de la siguiente forma, la clase como
tal , y la clase tiene a su vez un puntero a un objeto de la misma clase que es el
11. Nodo
siguiente o un puntero a la anterior, esto según el tipo de lista implementada.
Una estructura básica de un nodo para crear listas de datos seria:
struct nodo {
int dato;
struct nodo *otronodo;};
El campo "otronodo" puede apuntar a un objeto del tipo nodo. De este modo,
cada nodo puede usarse como un ladrillo para construir listas de datos, y cada uno
mantendrá ciertas relaciones con otros nodos.
Para acceder a un nodo de la estructura sólo necesitaremos un puntero a un nodo,
durante el presente curso usaremos gráficos para mostrar la estructura de las
estructuras de datos dinámicas. El nodo anterior se representará así:
Las estructuras auto-referenciadas se utilizan con frecuencia como elementos de
estructuras de datos tipo árbol y lista. En estos casos, un conjunto de objetos del
mismo tipo, están relacionadas entre sí mediante punteros contenidos en ellos
mismos, de forma que basta conocer la raíz del árbol o principio de la lista, para
poder acceder a todo el conjunto. En ocasiones, si tales listas son doblemente
enlazadas, es posible entrar en cualquier nodo y recorrer la totalidad del conjunto
en cualquier sentido.
Visto así, una lista enlazada es un tipo de dato auto-referenciado porque contienen
un puntero o link a otro dato del mismo tipo. Las listas enlazadas permiten
inserciones y eliminación de nodos en cualquier punto de la lista en tiempo
constante (suponiendo que dicho punto está previamente identificado o
localizado), pero no permiten un acceso aleatorio. Existen diferentes tipos de listas
enlazadas: Lista Enlazadas Simples, Listas Doblemente Enlazadas, Listas
Enlazadas Circulares y Listas Enlazadas Doblemente Circulares; por tanto un lista
12. que es una colección de datos se apoya de la clase auto-referenciada para su
funcionamiento y este tipo de clase a punto a otra clase del mismo tipo con un
puntero
Las estructuras dinámicas utilizan las clases auto-referenciadas para su
implementación; por tanto podemos hacer referencia a listas y arboles: cada
elemento dispone de dos o más punteros, pero las referencias nunca son a
elementos anteriores, de modo que la estructura se ramifica y crece igual que un
árbol.
• Listas abiertas: cada elemento sólo dispone de un puntero, que apuntará al
siguiente
• Listas circulares: o listas cerradas, son parecidas a las listas abiertas, pero
el último elemento apunta al primero. De hecho, en las listas circulares no puede
hablarse de "primero" ni de "último". Cualquier nodo puede ser el nodo de entrada
y salida.
• Listas doblemente enlazadas: cada elemento dispone de dos punteros, uno
a punta al siguiente elemento y el otro al elemento anterior. Al contrario que las
listas abiertas anteriores, estas listas pueden recorrerse en los dos sentidos.
LISTAS ENLAZADAS
Una lista enlazada también recibe el nombre de "lista concatenada", "lista
eslabonada" o "lista lineal".
Es una de las estructuras de datos fundamentales (Dinámica), y puede ser usada
para implementar otras estructuras de datos. Una lista enlazada es un conjunto de
elementos llamados nodos en los que cada uno de ellos contiene un dato y
también la dirección del siguiente nodo, donde el orden de los mismos se
establece mediante punteros.
13. La idea básica es que cada componente de la lista incluya un
puntero que indique donde puede encontrarse el siguiente componente por
lo que el orden relativo de estos puede ser fácilmente alterado modificando los
punteros; lo que permite, a su vez, añadir o suprimir elementos de la lista. El
primer elemento de la lista es la cabecera, que sólo contiene un puntero que
señala el primer elemento de la lista.
El último nodo de la lista apunta a nulo porque no hay más nodos en la lista. Se
usará el término NUL para designar el final de la lista.
Las listas enlazadas pueden ser implementadas en muchos lenguajes. Lenguajes
tales como Lisp y Scheme tiene estructuras de datos ya construidas, junto con
operaciones para acceder a las listas enlazadas. Lenguajes imperativos
u orientados a objetos tales como C# , C++ y Java, respectivamente, disponen de
referencias para crear listas enlazadas.
Las operaciones que podemos realizar sobre una lista enlazada son las
siguientes:
Recorrido: Esta operación consiste en visitar cada uno de los nodos que
forman la lista. Para recorrer todos los nodos de la lista, se comienza con el
primero, se toma el valor del campo liga para avanzar al segundo nodo, el
campo liga de este nodo nos dará la dirección del tercer nodo, y así
sucesivamente.
Inserción: Esta operación consiste en agregar un nuevo nodo a la lista. Para
esta operación se pueden considerar tres casos:
o Insertar un nodo al inicio.
o Insertar un nodo antes o después de cierto nodo.
14. o Insertar un nodo al final.
Borrado: La operación de borrado consiste en quitar un nodo de la lista,
redefiniendo las ligas que correspondan. Se pueden presentar cuatro casos:
o Eliminar el primer nodo.
o Eliminar el último nodo.
o Eliminar un nodo con cierta información.
o Eliminar el nodo anterior o posterior al nodo cierta con información.
15. Búsqueda. Esta operación consiste en visitar cada uno de los nodos,
tomando al campo liga como puntero al siguiente nodo a visitar.
Elementos de las listas
1. Nodo
2. Enlace o dirección de la lista
3. Dato: (esta dentro de un nodo, si el nodo esta vacio su dato es nulo
(NULL))
Ventajas de usar listas
o Las listas son dinámicas, es decir, podemos almacenar en ellas tantos
elementos como necesitemos, siempre y cuando haya suficiente espacio en
memoria.
o Al insertar un elemento en la lista, la operación tiene un tiempo constante
independientemente de la posición en la que se inserte, solo se debe crear
el nodo y modificar los enlaces.
o Al eliminar un elemento paso lo mismo que se menciono en el punto
anterior.
Desventaja de usar listas:
El acceso a un elemento es más lento, debido a que la información no está en
posiciones contiguas de memoria, por lo que no podemos acceder a un elemento con
base en su posición como se hace en los arreglos.
Representación de listas enlazadas en memoria
16. El siguiente ejemplo muestra la representación memoria de una lista enlazada en
la que cada nodo de la lista contiene un único carácter. Podemos obtener la lista
de caracteres o, en otras palabras, la cadena de la forma siguiente:
COMIENZO = 9, luego INFO [9] = N primer carácter.
ENLACE [9] = 3, luego INFO [3] = 0 segundo carácter.
ENLACE [3] = 6, luego INFO [6] = (carácter blanco) tercer carácter.
ENLACE [6] = 11, luego INFO [11] = E cuarto carácter.
ENLACE [11] = 7, luego INFO [7] = X quinto carácter.
ENLACE [7] = 10, luego INFO [10] = I sexto carácter.
ENLACE [10] = 4, luego INFO [4] = T séptimo carácter.
ENLACE [4] = -999 valor nulo, luego termina la lista.
Tipos de listas más comunes:
Listas Enlazadas Simples:
Lista simple o enlazada simple, solo tiene un enlace por nodo. Este enlace apunta
al siguiente nodo en la lista, o al valor NULL o final de la lista.
Listas enlazadas Dobles:
17. Esta lista es la que tiene doble enlace al nodo (dos vías). Cada nodo tiene dos
enlaces, uno apunta al nodo anterior (o apunta a NULL se es el nodo inicial) y el
otro apunta al nodo siguiente (o apunta a NULL si es el último nodo).
Listas Circulares:
Una lista circular es una lista lineal en la que el último nodo a punta al primero.
Las listas circulares evitan excepciones en las operaciones que se realicen sobre
ellas. No existen casos especiales, cada nodo siempre tiene uno anterior y uno
siguiente. En algunas listas circulares se añade un nodo especial de cabecera, de
ese modo se evita la única excepción posible, la de que la lista esté vacía.
o Listas enlazadas simples circulares
Cada nodo tiene un enlace, similar al de las listas enlazadas simples, excepto que
el siguiente nodo del último apunta al primero. Como en una lista enlazada simple,
los nuevos nodos pueden ser solo eficientemente insertados después de uno que
ya tengamos referenciado. Por esta razón, es usual quedarse con una referencia
solamente al último elemento en una lista enlazada circular simple, esto nos
permite rápidas inserciones al principio, y también permite accesos al primer nodo
18. desde el puntero del último nodo.
o Listas enlazadas doblemente circulares
En una lista enlazada doblemente circular, cada nodo tiene dos enlaces, similares
a los de la lista doblemente enlazada, excepto que el enlace anterior del primer
nodo apunta al último y el enlace siguiente del último nodo, apunta al primero.
Como en una lista doblemente enlazada, las inserciones y eliminaciones pueden
ser hechas desde cualquier punto con acceso a algún nodo cercano. Aunque
estructuralmente una lista circular doblemente enlazada no tiene ni principio ni fin,
un puntero de acceso externo puede establecer el nodo apuntado que está en la
cabeza o al nodo cola, y así mantener el orden tan bien como en una lista
doblemente enlazada.
Nodos centinelas
A veces las listas enlazadas tienen un nodo centinela (también llamado falso
nodo o nodo ficticio) al principio o al final de la lista, el cual no es usado para
guardar datos. Su propósito es simplificar o agilizar algunas operaciones,
asegurando que cualquier nodo tiene otro anterior o posterior, y que toda la lista
(incluso alguna que no contenga datos) siempre tenga un “primer y último” nodo.
19. Aplicaciones de las listas enlazadas:
Las listas enlazadas son usadas como módulos para otras muchas estructuras de
datos, tales como pilas, colas y sus variaciones.
El campo de datos de un nodo puede ser otra lista enlazada. Mediante este
mecanismo, podemos construir muchas estructuras de datos enlazadas con listas;
esta práctica tiene su origen en el lenguaje de programación Lisp, donde las listas
enlazadas son una estructura de datos primaria (aunque no la única), y ahora es
una característica común en el estilo de programación funcional.
A veces, las listas enlazadas son usadas para implementar vectores asociativos, y
estas en el contexto de las llamadas listas asociativas. Hay pocas ventajas en este
uso de las listas enlazadas; hay mejores formas de implementar éstas estructuras,
por ejemplo con árboles binarios de búsqueda equilibrados. Sin embargo, a veces
una lista enlazada es dinámicamente creada fuera de un subconjunto propio de
nodos semejante a un árbol, y son usadas más eficientemente para recorrer ésta
serie de datos.
Historia de las listas:
Las listas enlazadas fueron desarrolladas en 1955-56 y H por Cliff Shawerbert
Simon en RAND Corporation, como la principal estructura de datos para
su Lenguaje de Procesamiento de la Información (IPL). IPL fue usado por los
autores para desarrollar varios programas relacionados con la inteligencia artificial,
incluida la Máquina de la Teoría General, el Solucionador de Problemas
Generales, y un programa informático de ajedrez.
El diagrama clásico actual, que consiste en bloques que representan nodos de la
lista con flechas apuntando a los sucesivos nodos de la lista, apareció en
Programming the Logic Theory Machine, de Newell y Shaw. Newell y Simon
fueron reconocidos por el ACM Turing Award en 1975 por “hacer contribuciones
básicas a la inteligencia artificial, a la psicología del conocimiento humano y al
procesamiento de las listas”.
20. El problema de los traductores del procesamiento natural del lenguaje condujo
a Victor Yngve del Instituto Tecnológico de Massachusetts (MIT) a usar listas
enlazadas como estructura de datos en su COMIT, lenguaje de programación para
computadoras, que investigó en el campo de la Lingüística computacional. Un
informe de este lenguaje, titulado “A Programming Language for Mechanical
Translation” apareció en Mechanical Translation en 1958.
LISP, el principal procesador de listas, fue creado en 1958. Una de las mayores
estructuras de datos de LISP es la lista enlazada.
En torno a los 60, la utilidad de las listas enlazadas y los lenguajes que utilizaban
estas estructuras como su principal representación de datos estaba bien
establecida. Bert Green, del Lincoln Laboratory del MIT, publicó un estudio
titulado Computer languages for symbol manipulation en IRE Transaction on
Human Factors in Electronicsen marzo de 1961 que resumía las ventajas de las
listas enlazadas. Un posterior artículo, A Comparison of list-processing computer
languages de Bobrow y Raphael, aparecía en Communications of the ACM en
abril de 1964.
Muchos sistemas operativos desarrollados por la empresa TSC (Technical
Systems Consultants) usaron listas enlazadas simples como estructuras de
ficheros. Un directorio de entrada apuntaba al primer sector de un fichero y daba
como resultado porciones de la localización del fichero mediante punteros. Los
sistemas que utilizaban esta técnica incluían Flex (para el Motorola 6800 CPU),
mini-Flex (la misma CPU) y Flex9 (para el Motorola 6809 CPU). Una variante
desarrollada por TSC se comercializó a Smoke Signal Broadcasting en California,
usando listas doblemente enlazadas del mismo modo.
El sistema operativo TSS, desarrollado por IBM para las máquinas System
360/370, usaba una lista doblemente enlazada para su catálogo de ficheros de
sistema. La estructura de directorios era similar a Unix, donde un directorio podía
contener ficheros u otros directorios que se podían extender a cualquier
profundidad. Una utilidad fue creada para arreglar problemas del sistema después
de un fallo desde las porciones modificadas del catálogo de ficheros que estaban
21. a veces en memoria cuando ocurría el fallo. Los problemas eran detectados por
comparación de los enlaces posterior y anterior por consistencia. Si el siguiente de
ellos era corrupto y el anterior enlace del nodo infectado era encontrado, el enlace
posterior era asignado al nodo marcado con el enlace anterior.
22. CONCLUSIÓN
La versatilidad de la implementación de estructuras dinámicas permite aprovechar
más eficientemente los recursos de memoria pues estas se amplían y contraen
durante la ejecución del programa, basada en los registros de almacenamiento de
datos del programa.
Por lo anteriormente mencionado, podemos afirmar que una estructura dinámica
de datos es una colección de elementos (llamadas nodos) que son normalmente
registros.
Las estructuras dinámicas de datos, referidas en este trabajo fueron listas, las
cuales son definas como una colección de elementos llamados nodos. Cada nodo
contiene un dato y una referencia al siguiente nodo; las mismas se utilizan para
almacenamiento de datos del mundo real, que están cambiando constantemente;
ejemplo característico, es la lista de pasajeros de una línea aérea.
Por otro lado, para su recorrido e implementación requiere de estructuras o clases
auto-referenciadas, las cuales contiene un miembro de apuntador que apunta a
una estructura del mismo tipo de estructura; es decir se define un tipo, struct
node, donde el miembro nextPtr apunta a una estructura de tipo struct node, una
estructura del mismo tipo que la que se está declarando en la misma clase, de ahí
el término de "estructura autoreferenciada". El apuntador nextPtr se conoce como
un enlace o vínculo, ya que sirve para vincular una estructura de tipo struct node
con otra estructura del mismo tipo.
Por ello podemos mencionar que la implementación de las estructuras auto-
referenciadas pueden ser enlazadas juntas para formar útiles estructuras de datos
como son las listas, las colas, las pilas y los árboles; permitiendo por tanto
definir la organización e interrelación de los datos y un conjunto de operaciones
que se pueden realizar sobre ellos.
23. BIBLIOGRAFIA
Fuentes Primarias:
1. http://www.Slideshare.net/PatriciaU/estructuras-dinamicas
2. http://es.wikipedia.org/wiki/Lista_(inform%C3%A1tica)
3. http://casicodigo.blogspot.com/2012/10/listas-enlazadas-simples-en-c.html
4. http://www.calcifer.org/documentos/librognome/glib-lists-queues.html
Fuentes Bibliográficas
1. Aho, Alfred. Estructuras de Datos y Algoritmos. Editorial McGraw-Hill
2. Luis Joyanes. Programación en C: Metodología, Estructura de Datos y Objetos.
Editorial McGraw-Hill
24. ANEXOS
CODIGO PARA CORRER UNA LISTA DOBLEMENTE ENLAZADA
Ejemplo Lista Doblemente Enlazada
Clase donde se definen los procedimientos a utilizar
También se define el nodo que va a recorrer la lista “ant” “y sig”
Se define el nodo “raíz”.
