Estructura de Datos Listas Enlazadas Dinámicas
Tema Listas Enlazadas Dinámicas.
Contenido.
1. Introducción.
2. Punteros.
3. Que son las listas dinámicas.
4. Tipos de listas enlazadas a estudiar.
5. Listas Simplemente Enlazadas.
6. Ejemplo de una lista simplemente enlazada.
7. Listas Doblemente enlazadas
8. Listas Simplemente enlazadas circulares.
9. Listas Doblemente enlazadas circulares.
10. La clase list en c++.
11. Aplicaciones de las listas enlazadas dinámicas.
Introducción
En este capítulo se comienza el estudio de las estructuras de datos dinámicas. Aprenderá a trabajar
con punteros y asignación y liberación de memoria.
Hasta ahora ha trabajado con estructuras de datos estáticas; donde se reserva un espacio de memoria
fijo, dentro del que se debe trabajar, como es el caso de los arreglos, a partir de este momento
comenzamos a trabajar con ED dinámicas, es decir, ya no se tiene un espacio fijo de memoria
reservado, sino, que en la medida que necesite solicitara memoria, y en la medida que ya no necesite,
liberara la memoria.
Punteros.
Un puntero, es un concepto fundamental en programación y se refiere a una variable especial que
almacena la dirección de memoria de otra variable en lugar de contener un valor directo.
Los punteros son ampliamente utilizados en lenguajes de programación como C, C++, y otros para
gestionar la memoria y permitir la manipulación eficiente de datos.
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
Dirección de Memoria: Un puntero almacena la dirección de memoria de otra variable. En lugar de
contener el valor real de la variable, apunta a su ubicación en la memoria.
Tipos de Datos: Los punteros tienen tipos de datos asociados, lo que significa que pueden apuntar a
variables de un tipo específico. Por ejemplo, un puntero a un entero apunta a una variable entera, y
un puntero a un carácter apunta a una variable de tipo carácter.
Acceso a Datos: Para acceder al valor de la variable a la que apunta un puntero, se utiliza la operación
de "desreferenciación". Esto significa que se utiliza el puntero para acceder y modificar el valor de la
variable en la dirección de memoria a la que apunta.
Gestión de Memoria: Los punteros son esenciales para la gestión de la memoria en lenguajes de
programación de bajo nivel. Permiten la asignación y liberación de memoria dinámica, lo que es útil
para crear estructuras de datos complejas.
Arreglos y Estructuras de Datos: Los punteros son utilizados para crear estructuras de datos
dinámicas, como listas enlazadas y árboles, y para manipular arreglos de datos.
Referencias a Funciones: En algunos casos, los punteros se utilizan para referenciar y llamar a
funciones dinámicamente.
Eficiencia y Control: Los punteros ofrecen un alto nivel de control y eficiencia en la programación,
pero también pueden ser fuente de errores si no se manejan correctamente, como la famosa
"violación de acceso" (segfault).
Ejemplo:
int numero = 44; // variable de tipo entero, un numero
int* puntero; // Declaración de un puntero a un entero.
puntero = № // Asignación del puntero a la dirección de memoria de 'numero'
int valor = *puntero; // Acceso al valor de 'numero' a través del puntero
Un puntero es una herramienta poderosa en programación que permite trabajar con direcciones de
memoria y datos de manera más eficiente y flexible, pero también requiere un manejo cuidadoso para
evitar errores de acceso a la memoria.
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
Que son las Listas Dinámicas.
Las Listas dinámicas son un conjunto de elementos que crecen y decrecen dinámicamente en función
de si se necesitan más elementos ó si no se necesitan. El trabajo con ellas es mejor comparado con los
arreglos. La ventaja más notoria sobre ellos es que la inserción y eliminación es más rápida y sólo se
utiliza el espacio en memoria realmente necesario para la aplicación.
Tipos de Listas enlazadas a estudiar.
Las diferentes Listas Enlazadas que se estudian son:
• Listas Simplemente Enlazadas.
• Listas Doblemente enlazadas.
• Listas Simplemente Enlazadas circulares.
• Listas Doblemente Enlazadas Circulares.
• Listas con Nodo Cabeza.
Listas Simplemente Enlazadas.
Es una lista que crece y decrece dinámicamente, cada uno de los elementos que la componen
tiene un enlace al siguiente de la lista, es decir, al que le sigue. Esto significa, que en ese
enlace, tiene almacenada la dirección en memoria de donde se encuentra el siguiente
elemento que le sigue.
Representación gráfica de la lista simplemente enlazada.
Gráficamente se puede representar una lista simplemente enlazada como el gráfico de la
figura 1. En él se ven un conjunto de elementos, para este caso, caracteres; donde cada
elemento tiene la posición de donde se encuentra el siguiente elemento.
PRIMERO ULTIMO
A B C D E
Fig1
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
Donde usar una Lista Simplemente Enlazada.
En cualquier problema donde se maneje un conjunto de elementos, y cada uno se encuentre a
continuación de otro.
Por ejemplo: Si se tiene una lista de varias asignaturas, y de cada una de ellas se conoce el
nombre, y la cantidad de horas. O una lista de estudiantes, o una lista de médicos, etc.
Operaciones
Insertar un elemento, eliminar un elemento, buscar, etc.
Listas Doblemente Enlazadas
Es una lista que crece y decrece dinámicamente, donde, cada uno de los elementos que la
componen tiene un enlace al siguiente, es decir al que le sucede y otro enlace, al que le
antecede.
Una lista doblemente enlazada es muy parecida a la lista estudiada en el apartado anterior. El
tratamiento es el mismo con la diferencia de que en este caso, cada nodo va a tener dos
enlaces, uno al antecesor y otro al sucesor. Esta lista tiene asociado tres campos donde el
primero apunta al antecesor, el campo de información que contiene la información del nodo,
y el tercer campo apuntará al siguiente nodo de la lista.
En resumen, los campos son los siguientes:
❖ Enlace izquierdo
❖ Información
❖ Enlace derecho
Representación gráfica de la lista doblemente enlazada
Gráficamente se puede representar una lista doblemente enlazada como el gráfico de la figura
3. En él se ven un conjunto de elementos, donde cada elemento tiene la posición de donde se
encuentra el siguiente elemento y donde se encuentra el anterior.
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
PRIMERO
ULTIMO
A B C D E
Fig. 2
Operaciones Básicas de la lista DE
El trabajo con este tipo de lista es similar al trabajo con las anteriores, pero tomando en
cuenta que ahora tienen un enlace más.
Las operaciones básicas serían también las mismas, con la diferencia de que su
implementación difiere, ya que ahora cada nodo tiene un enlace más, un enlace al nodo
anterior o que le precede.
Listas Circulares.
Una lista circular es una lista donde todos los elementos que la componen, tiene un enlace a
otro elemento. Ningún elemento apunta a null.
Podemos tener listas circulares de varios tipos tales como:
• Listas simplemente enlazadas circulares.
• Listas doblemente enlazadas circulares.
• Listas con nodos cabezas circulares, listas que se estudian en este tema.
Listas SE Circulares.
Que son
Una lista SE circular es una lista Simplemente enlazada, pero que además es circular, en la
que el último elemento enlaza con el primero. Es posible acceder a cualquier elemento de la
lista circular desde cualquier punto dado. Las operaciones en listas circulares son similares a
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
las estudiadas anteriormente, con la diferencia que los nodos apuntan siempre a un nodo,
nunca a NULL.
En estas listas no existe ni primero ni último elemento, aunque se debe elegir
obligatoriamente un puntero para referenciar la lista.
Tiene el inconveniente de que requiere un diseño cuidadoso para evitar caer en un bucle
Infinito.
Podemos ver ya sea listas simplemente enlazadas circulares o listas doblemente enlazadas
circulares.
Representación gráfica de la Lista Simplemente Enlazada Circular.
Gráficamente se puede representar una lista simplemente enlazada como el gráfico de la
figura 1. En él se ve, un conjunto de elementos, en este caso, caracteres; cada elemento tiene
la posición de donde se encuentra el siguiente elemento.
PRIMERO ULTIMO
A B C D E
Fig3.
Listas Doblemente Enlazadas Circulares.
Las listas doblemente enlazadas también pueden ser circulares. Las listas son estructuras
muy ricas y variadas.
En muchas aplicaciones se requiere recorrer la lista en ambas direcciones. Estos recorridos se
pueden conseguir manteniendo dos campos de enlace en cada nodo en vez de tener un solo
enlace como se vio al estudiar las listas simplemente enlazadas.
Estos enlaces se utilizan para denotar la dirección del predecesor y sucesor de un nodo dado.
El predecesor se llama enlace izquierdo o anterior y el sucesor enlace derecho o siguiente.
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
Una lista circular doblemente enlazada, es una lista en la que cada nodo apunta al siguiente y
al anterior y donde el “ultimo” elemento apunta al primer elemento y el primero apunta al
último nodo. En estas listas no existe ni primero ni un último elemento, aunque se debe elegir
obligatoriamente un puntero para referenciar la lista.
Representación gráfica de la Lista Doblemente Enlazada Circular
Gráficamente se puede representar una lista doblemente enlazada circular como el gráfico de
la figura 2. En él se ven un conjunto de elementos, en este caso, caracteres; donde cada
elemento tiene la posición de donde se encuentra el siguiente elemento y donde se encuentra
el que le antecede; y el último tiene la dirección del primero, como el primero, tiene la
dirección del último.
PRIMERO ULTIMO
A B C D E
Fig. 4
Operaciones Básicas
Para trabajar con las listas, ó ese conjunto de elementos, se debe poder crear la lista e ir
insertando elementos. Entre las operaciones a realizar se tienen las mismas estudiadas
anteriormente, tomando en cuenta la diferencias entre ellas, modificando las operaciones,
pues al insertar y/o eliminar elementos en la lista, se deben actualizar correctamente los
enlaces.
Debe tomar en cuenta que es una lista Doblemente Enlazada, pero que ahora también es
circular.
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
Listas con Nodos Cabezas.
Muchas veces es necesario trabajar con un nodo extra de la lista, que pueda dar información
general de ella, como, por ejemplo, la cantidad de elementos que tiene. Este nodo se llama
Nodo Cabeza. Se puede usar como ya se dijo anteriormente para dar alguna información
general de la lista ó sencillamente para marcar el inicio de ella.
Podemos utilizar los nodos cabezas cada vez que sea necesario y se pueden asociar a:
❖ Listas Simplemente Enlazadas.
❖ Listas Doblemente Enlazadas.
❖ Listas Simplemente Enlazadas Circulares.
❖ Listas Doblemente Enlazadas Circulares.
Listas Simplemente Enlazada con Nodo Cabeza.
Es una Lista simplemente enlazada que se le adiciona un nodo más, el nodo cabeza.
Representación gráfica de la lista simplemente enlazada con Nodo Cabeza
Gráficamente se puede representar una lista simplemente enlazada con nodo cabeza como el
gráfico de la figura 3. En él se ven un conjunto de elementos, para este caso, caracteres;
donde cada elemento tiene la posición de donde se encuentra el siguiente elemento, pero
además se tiene un nodo extra, el nodo cabeza.
Cabeza
4 A B C D
Fig. 5
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
Listas Doblemente Enlazada con Nodo Cabeza
Una lista doblemente enlazada con nodo cabeza es una lista doblemente enlazada a la que se
le adiciona otro nodo al inicio de ella, es decir un nodo cabeza que va a tener información
general de la lista y va a marcar su inicio.
Representación gráfica de la Lista Doblemente Enlazada con Nodo Cabeza.
Gráficamente se puede representar una lista doblemente enlazada con nodo cabeza como el
gráfico de la figura 4. En él se ven un conjunto de elementos, para este caso, caracteres;
donde cada elemento tiene la posición de donde se encuentra el siguiente elemento.
CABEZA
4 A B C D
Fig. 6
Listas Simplemente Enlazada Circular con Nodo Cabeza.
Una lista simplemente enlazada circular con nodo cabeza no es más que una lista
simplemente enlazada circular, vista anteriormente (Figura 1), que, además se le adiciona un
nodo, que va a tener una información general de la lista o servirá para tener la referencia de
donde comienza esta, llamado nodo cabeza
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
Representación gráfica de la lista simplemente enlazada Circular con Nodo
Cabeza
Gráficamente se puede representar una lista simplemente enlazada circular con nodo cabeza
como el gráfico de la figura 5. En él se ven un conjunto de elementos, en este caso, caracteres;
donde cada elemento tiene la posición de donde se encuentra el siguiente elemento.
Cabeza
4 A B C D
Fig. 7
Listas Simplemente Enlazada.
Representación en memoria de una Lista Simplemente Enlazada:
Como se puede apreciar de la figura anterior, la lista está formada por varios elementos o un
conjunto de elementos, en memoria interna, también habrá que permitir almacenar ese
conjunto de elementos. Para la explicación se utilizará una lista de asignaturas, donde de cada
una de ellas se conoce el código, el nombre y la cantidad de horas. Quedando la definición de
la siguiente forma:
struct nodoasig {
string codigo, descripcion;
int cantidad;
struct nodoasig* siguiente;
};
nodoasig* primero, * ultimo;
//Para iniciar los valores de primero y ultimo
void iniciar()
{
primero = NULL;
ultimo = NULL;
}
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
Operaciones Básicas:
Para trabajar con las listas, ó ese conjunto de elementos, se debe poder crear la lista e ir
insertando elementos. Entre las operaciones a realizar están:
• Vacía
Esta operación verifica si la lista no tiene ningún elemento, en cuyo caso devuelve
verdadero.
int vacia()
{
if (primero==NULL)
return 1;
else
return 0;
• Insertar.
• La operación insertar, permitirá ir adicionando elementos en la lista.
• Podría insertarse dichos elementos por el inicio, principio, primero de la lista, o
al final de ella, o en una determinada posición.
• A continuación, se expone el código asociado a estas operaciones de inserción
Operación que inserta un elemento por delante de la lista: Al insertar de
esta forma, cuando llegue un elemento a la lista, este pasará a ser el primero
de ella
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
void insertar_delante(string cod, string nomb, int cant)
{
nodoasig* nodo;
nodo = new nodoasig;
nodo->siguiente = NULL;
nodo->codigo = cod;
nodo->descripcion = nomb;
nodo->cantidad = cant;
if (vacia())
{
primero = nodo;
ultimo = nodo;
}
else
{
nodo->siguiente = primero;
primero = nodo;
}
return;
Operación que inserta un elemento por detrás de la lista: Al insertar de
esta forma, cuando llegue un elemento a la lista, este pasará a ser el último de
ella
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
void insertar_detras(string cod, string nomb, int cant)
{
nodoasig* nodo;
nodo = new nodoasig;
nodo->siguiente = NULL;
nodo->codigo = cod;
nodo->descripcion = nomb;
nodo->cantidad = cant;
if (vacia())
{
primero = nodo;
ultimo = nodo;
}
else
{
ultimo->siguiente = nodo;
ultimo = nodo;
}
return;
Operación que inserta un elemento ordenadamente en la lista: En este
caso se está insertando de menor a mayor, en orden ascendente. Al insertar de
esta forma, cuando llegue un elemento a la lista, se buscará el lugar donde
debe ir el elemento a insertar, se toma en cuenta también, que si es menor a
todos deberá ser entonces el primero de la lista, si es mayor a todos, deberá
ocupar el último lugar en la lista. A continuación, se muestra el código
asociado a ello.
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
int insertar_ordenadamente(string cod, string nomb, int cant)
{
nodoasig* nodo, * p, * q;
nodo = new nodoasig;
nodo->siguiente = NULL;
nodo->codigo = cod;
nodo->descripcion = nomb;
nodo->cantidad=cant;
if (vacia())
{
primero = nodo;
ultimo = nodo;
}
else
{
p = primero;
q = primero;
while ((p != NULL) && (p->codigo < cod))
{
q = p;
p = p->siguiente;
if (p == primero)
{
nodo->siguiente = primero;
primero = nodo;
}
else
{
q->siguiente = nodo;
nodo->siguiente = p;
if (p == NULL)
ultimo = nodo;
}
return 0;
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
Eliminar.
• Esta operación es para eliminar un determinado elemento en la lista. ¿Cuál
elemento podría ser? Uno que el usuario nos diga, es decir, la persona que está
manejando el programa. También podría tener otras variantes, tales como que el
elemento que se quiere eliminar esta en la primera posición, o está en la última
posición, o se encuentra en otra parte en la lista.
void eliminar(string valor)
{
nodoasig* p, * q;
q = primero;
p = primero;
while ((p != NULL) && (p->codigo != valor))
{
q = p;
p = p->siguiente;
if (p == NULL)
cout << "No existe ese elemento en la lista";
else
{
if (primero == ultimo)
{
iniciar();
}
else
{
if (p == primero)
primero = p->siguiente;
else
if (p == ultimo)
ultimo = q;
else
q->siguiente = p->siguiente;
}
}
return;
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
• Mostrar.
• En esta operación se mostrarán los diferentes elementos que componen la lista.
Si la lista está vacía, se muestra un mensaje de error, caso contrario se recorre y
se va mostrando uno a uno cada elemento de ella, hasta llegar al final de la lista.
Utilizando While:
void mostrar()
{
nodoasig* p;
if (vacia())
cout << "Lista vacia";
else
{
p = primero;
while (p != NULL) {
cout << p->codigo << endl;
cout << p->descripcion << endl;
cout << p->cantidad << endl;
p = p->siguiente;
}
(void)getchar();
}
return;
}
Utilizando for:
void mostrar_for()
{
nodoasig* p;
if (vacia())
cout << "Lista vacia";
else
{
int i;
p = primero;
for (i = 1; p != NULL; i++) {
cout << p->codigo << endl;
cout << p->descripcion << endl;
cout << p->cantidad << endl;
p = p->siguiente;
}
(void)getchar();
}
return;
}
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
Otras operaciones que se podrían implementar serian:
• Ir al Primero.
• Ir al Último.
• Ir al Anterior.
• Ir al siguiente.
• Buscar un determinado elemento.
• Ordenar la lista.
• Máximo.
• Minimo
• Etc.
Listas Doblemente Enlazadas.
Definición en memoria de la lista doblemente enlazada
Se define un nodo, con la información de asignaturas, ya que, como ejemplo, se está
trabajando con esta lista, pero los datos estarán de acorde con la lista con la que estén
trabajando. Se tienen además dos campos de tipo puntero, uno enlazará al nodo que le
antecede y otro enlazará al nodo que le sucede.
struct nodoasig {
string codigo, descripcion;
int cantidad;
struct nodoasig *siguiente, *anterior;
};
nodoasig* primero, * ultimo;
//Para iniciar los valores de primero y ultimo
void iniciar()
{
primero = NULL;
ultimo = NULL;
}
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
Operaciones básicas
Las operaciones serán las mismas que hemos estudiado para las listas simplemente
enlazadas, tomando en cuenta que defiere su implementación, ya que ahora es doblemente
enlazada, tiene dos enlaces.
Listas Simplemente Enlazadas Circulares.
Definición en memoria de la lista simplemente enlazada circular
Se define un nodo, con la información de asignaturas, ya que, como ejemplo, se está
trabajando con esta lista, pero los datos estarán de acorde con la lista con la que estén
trabajando. Se tienen además un campo de tipo puntero, que enlazará al nodo que le sucede.
Se debe tomar en cuanta que siempre que se realizan inserciones o eliminaciones en la lista,
el ultimo deberá enlazar al primero de la lista.
struct nodoasig {
string codigo, descripcion;
int cantidad;
struct nodoasig *siguiente;
};
nodoasig* primero, * ultimo;
//Para iniciar los valores de primero y ultimo
void iniciar()
{
primero = NULL;
ultimo = NULL;
}
Operaciones básicas
Las operaciones serán las mismas que hemos estudiado para las listas simplemente
enlazadas, tomando en cuenta que defiere su implementación, ya que ahora es circular.
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
Listas Doblemente Enlazadas Circulares.
Definición en memoria de la lista doblemente enlazada circular
Se define un nodo, con la información de asignaturas, ya que, como ejemplo, se está
trabajando con esta lista, pero los datos estarán de acorde con la lista con la que estén
trabajando. Se tienen además dos campos de tipo puntero, uno enlazará al nodo que le
antecede y otro enlazará al nodo que le sucede. Se debe tomar en cuenta que siempre que se
realizan inserciones o eliminaciones en la lista, el ultimo deberá enlazar al primero de la lista
y el primero al último.
struct nodoasig {
string codigo, descripcion;
int cantidad;
struct nodoasig *siguiente, *anterior;
};
nodoasig* primero, * ultimo;
//Para iniciar los valores de primero y ultimo
void iniciar()
{
primero = NULL;
ultimo = NULL;
}
Operaciones básicas
Las operaciones serán las mismas que hemos estudiado para las listas simplemente
enlazadas, tomando en cuenta que defiere su implementación, ya que ahora es circular y tiene
dos enlaces.
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
La clase list en c++
En C++, std::list, es una clase de la Biblioteca Estándar de C++ que representa una lista doblemente
enlazada. Esta clase proporciona una implementación de una lista enlazada que permite el acceso
rápido a los elementos en cualquier posición y es eficiente para insertar y eliminar elementos en
cualquier parte de la lista.
std::list, ofrece una variedad de métodos para manipular y acceder a los elementos de la lista. Estos
métodos incluyen:
push_back(): para agregar elementos al final de la lista.
push_front(): para agregar elementos al principio de la lista,
pop_back() y pop_front() : para eliminar elementos del final y del principio de la lista
respectivamente.
otros métodos como insert(), erase(), begin(), end(), entre otros, para realizar diversas operaciones en
la lista.
Ejemplo del uso de list, para la lista de asignaturas
#include <iostream>
#include <list>
#include <string>
#include <algorithm>
// Definición de la estructura para la asignatura
struct Asignatura {
std::string codigo;
std::string nombre;
int horas;
// Constructor para crear una nueva asignatura
Asignatura(const std::string& cod, const std::string& nom, int h) : codigo(cod), nombre(nom),
horas(h) {}
};
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
// Funcion para mostrar una asignatura
void mostrarAsignatura(const Asignatura& asignatura) {
std::cout << "COdigo: " << asignatura.codigo << ", Nombre: " << asignatura.nombre << ",
Horas: " << asignatura.horas << std::endl;
}
int main() {
// Crear una lista enlazada de asignaturas
std::list<Asignatura> listaAsignaturas;
// Agregar algunas asignaturas a la lista
listaAsignaturas.emplace_back("SIS204", "Estructura de Datos", 16);
listaAsignaturas.emplace_back("SIS301", "Analisis", 16);
listaAsignaturas.emplace_back("SIS401", "Pasantia", 24);
// Mostrar las asignaturas en la lista
std::cout << "Lista de asignaturas:" << std::endl;
for (const auto& asignatura : listaAsignaturas) {
std::cout << "Codigo: " << asignatura.codigo << ", Nombre: " << asignatura.nombre
<< ", Horas: " << asignatura.horas << std::endl;
}
// Mostrar el número de asignaturas en la lista
std::cout << "Numero de asignaturas: " << listaAsignaturas.size() << std::endl;
// Eliminar la asignatura con codigo sis301
listaAsignaturas.remove_if([](const Asignatura& asignatura) { return asignatura.codigo ==
"SIS301"; });
// Mostrar el número de asignaturas en la lista
std::cout << "Numero de asignaturas: " << listaAsignaturas.size() << std::endl;
std::cout << "Lista de asignaturas:" << std::endl;
for (const auto& asignatura : listaAsignaturas) {
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
std::cout << "Codigo: " << asignatura.codigo << ", Nombre: " << asignatura.nombre
<< ", Horas: " << asignatura.horas << std::endl;
}
listaAsignaturas.push_back(Asignatura("SIS100", "COMPUTACION", 16));
// listaAsignaturas.push_back(Asignatura(2, "Física", 5));
// listaAsignaturas.push_back(Asignatura(3, "Programación", 6));
std::cout << "Lista de asignaturas:" << std::endl;
for (const auto& asignatura : listaAsignaturas) {
std::cout << "Codigo: " << asignatura.codigo << ", Nombre: " << asignatura.nombre
<< ", Horas: " << asignatura.horas << std::endl;
}
// Ordenar la lista de asignaturas por código
listaAsignaturas.sort([](const Asignatura& a, const Asignatura& b) { return a.codigo <
b.codigo; });
std::cout << "Lista de asignaturas Ordenada:" << std::endl;
for (const auto& asignatura : listaAsignaturas) {
std::cout << "Codigo: " << asignatura.codigo << ", Nombre: " << asignatura.nombre
<< ", Horas: " << asignatura.horas << std::endl;
}
//BUSCAR Y MOSTRAR UNA Asignatura
auto it = std::find_if(listaAsignaturas.begin(), listaAsignaturas.end(), [](const Asignatura&
asignatura) { return asignatura.codigo == "SIS401"; });
if (it != listaAsignaturas.end()) {
std::cout << "Asignatura encontrada:" << std::endl;
mostrarAsignatura(*it);
} else {
std::cout << "Asignatura no encontrada." << std::endl;
}
// Mostrar todas las asignaturas en la lista
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
std::cout << "Lista de asignaturas:" << std::endl;
for (const auto& asignatura : listaAsignaturas) {
mostrarAsignatura(asignatura);
}
// Limpiar la lista de asignaturas
listaAsignaturas.clear();
// Comprobar si la lista está vacía después de borrar
if (listaAsignaturas.empty()) {
std::cout << "La lista de asignaturas esta vacia." << std::endl;
}
return 0;
}
Aplicaciones de las Listas enlazadas.
Las listas enlazadas son una estructura de datos fundamental en ciencias de la computación y tienen
muchas aplicaciones en el desarrollo de software. Aquí hay algunas aplicaciones comunes de las listas
enlazadas en computación:
1. Gestión de memoria: Las listas enlazadas son utilizadas internamente por muchos sistemas
operativos para gestionar la memoria asignada dinámicamente. Por ejemplo, en sistemas operativos
basados en Unix, como Linux, las estructuras de datos de control de procesos y gestión de memoria a
menudo se implementan como listas enlazadas.
2. Implementación de estructuras de datos más complejas: Las listas enlazadas se utilizan como
componentes básicos para construir estructuras de datos más complejas, como pilas, colas, listas
circulares, listas doblemente enlazadas, etc.
3. Listas de reproducción: En aplicaciones de multimedia, como reproductores de música y video, las
listas enlazadas pueden usarse para crear listas de reproducción donde cada nodo de la lista
representa una canción o un video.
Docente: Ing. Rosa Almaraz
Estructura de Datos Listas Enlazadas Dinámicas
4. Editores de texto: En editores de texto y procesadores de texto, las listas enlazadas se pueden usar
para almacenar líneas de texto donde cada nodo de la lista representa una línea del documento.
5. Implementación de gráficos: En la representación de gráficos, como grafos y árboles, las listas
enlazadas pueden usarse para representar las aristas y los nodos. Por ejemplo, en una representación
de grafo basada en listas de adyacencia, cada nodo tendría una lista enlazada de los nodos adyacentes.
6. Cachés y buffers: En aplicaciones donde se requiere un almacenamiento temporal de datos, como
en sistemas de almacenamiento en caché y buffers de red, las listas enlazadas se pueden utilizar para
almacenar y administrar los datos de manera eficiente.
7. Recorrido de estructuras de datos: Las listas enlazadas son útiles para recorrer estructuras de datos
de manera recursiva o iterativa, como árboles binarios y grafos.
Estas son solo algunas de las muchas aplicaciones de las listas enlazadas en la informática. Su
flexibilidad y eficiencia en la inserción y eliminación de elementos las hacen una opción popular en
una amplia variedad de problemas de programación y desarrollo de software.
Docente: Ing. Rosa Almaraz
