Universidad Nacional San Cristóbal de Huamanga

Facultad de Ingeniería de Minas Geología y Civil

Escuela Profesional de Ingeniería de Sistemas

TAREA ACADÉMICA n° 04
Listas simples enlazadas

Jordy Julian Huamán Lozano

Código 27115801

Docente

MSc. Ing. Fredy Barrientos

Ayacucho – Perú

Agosto de 2020
Contenido:
DESARROLLO Y RESULTADOS 3

1.1 Desarrollo 3

1.1.1 Ejercicio 3.2.1 3

1.1.2 Ejercicio 3.2.2 13

1.2 Resultados e interpretación 16

1.2.1 Ejercicio 3.2.1 16

1.2.2 Ejercicio 3.2.2 19

1.3 Repositorio 21

CONCLUSIONES 22

2
 1 DESARROLLO Y RESULTADOS
1.1 Desarrollo

1.1.1 Ejercicio 3.2.1

Para el siguiente programa se muestra una variedad de métodos que puede tener una
lista enlazada simple para el registro de estudiantes:

● Creamos la clase Nodo con sus atributos, su constructor y sus métodos set y get para
el control de nodos simplemente enlazados:

public class Nodo {

//Referencia a estudiante
Estudiante estudiante;
//Referencia al siguiente nodo
Nodo siguiente = null;

//Inicializa estudiante
public Nodo(Estudiante estudiante) {
this.estudiante = estudiante;
}

public Estudiante getEstudiante() {

return estudiante;
}

public void setEstudiante(Estudiante estudiante) {

this.estudiante = estudiante;
}

public Nodo getSiguiente() {

return siguiente;
}

public void setSiguiente(Nodo siguiente) {

this.siguiente = siguiente;
}

● Creamos la clase Estudiante y sus respectivos atributos, su constructor y sus

métodos get y set donde se guardarán los datos que ingresemos:
public class Estudiante {

private int idEstudiante;

private String nombre;
private String apellido;
private int edad;

public void Estudiante() {

this.idEstudiante = 0;
this.nombre = null;
this.apellido = null;
this.edad = 0;
}

3
 public Estudiante(int idEstudiante, String nombre, String
apellido, int edad) {
this.idEstudiante = idEstudiante;
this.nombre = nombre;
this.apellido = apellido;
this.edad = edad;
}

public int getIdEstudiante() {

return idEstudiante;
}

public void setIdEstudiante(int idEstudiante) {

this.idEstudiante = idEstudiante;
}

public String getNombre() {

return nombre;
}

public void setNombre(String nombre) {

this.nombre = nombre;
}

public String getApellido() {

return apellido;
}

public void setApellido(String apellido) {

this.apellido = apellido;
}

public int getEdad() {

return edad;
}

public void setEdad(int edad) {

this.edad = edad;
}

 También una clase Lista el cual alberga los métodos correspondientes de

agregar, eliminar, buscar, y mostrar los elementos de la lista:

public class Lista {

//Referencia a la cabeza de la lista

Nodo cabeza = null;
int longitud = 0;

//Insertar elementos al inicio de la lista

public void insertarInicio(Estudiante estudiante) {
//Crear un nuevo nodo
Nodo nodo = new Nodo(estudiante);

4
 //Cabeza de la lista se vuelve cola(siguiente)
nodo.siguiente = cabeza;
//El nodo recien creado se vuelve cabeza
cabeza = nodo;
longitud++;

System.out.print("Elemento insertado por la cabeza:

");
System.out.print(" " +
nodo.estudiante.getIdEstudiante());
System.out.print(" " + nodo.estudiante.getNombre());
System.out.print(" " +
nodo.estudiante.getApellido());
System.out.print(" " + nodo.estudiante.getEdad() +
"\n");

//Insertar elementos al final de la lista;

public void insertarFinal(Estudiante estudiante) {
//Creamos un nuevo nodo de estudiante
Nodo nodo = new Nodo(estudiante);
//Verificar si la lista esta vacía
if (cabeza == null) {
cabeza = nodo;
} else {
//Crear un nuevo puntero apuntando a la cabeza
Nodo puntero = cabeza;
//Puntero recorrer la lista
while (puntero.siguiente != null) {
//El Puntero apunta al siguiente
puntero = puntero.siguiente;
}
//El puntero siguiente vale el nuevo nodo
puntero.siguiente = nodo;
}
longitud++;

System.out.print("Elemento insertado por el final:

");
System.out.print(" " +
nodo.estudiante.getIdEstudiante());
System.out.print(" " + nodo.estudiante.getNombre());
System.out.print(" " +
nodo.estudiante.getApellido());
System.out.print(" " + nodo.estudiante.getEdad() +
"\n");
}

//Insertar en una posición particular

public void insertarDespues(int posicion, Estudiante
estudiante) {
//Crear un nuevo nodo de estudiante
Nodo nodo = new Nodo(estudiante);
//Si la lista está vacía
if (cabeza == null) {
cabeza = nodo; //Se agrega el nuevo nodo
} else {
//Crear puntero apuntando a la cabeza
Nodo puntero = cabeza;

5
 //Crear el contador para indeicara qué número
está apuntando el puntero
int contador = 0;
//puntero recorre la lista
while (contador < posicion && puntero.siguiente
!= null) {
//El puntero apunta a el suguiente
puntero = puntero.siguiente;
contador++;
}
//Conecta por la derecha
nodo.siguiente = puntero.siguiente;
//Conecta por la izquierda
puntero.siguiente = nodo;
}
longitud++;

System.out.print("Elemento insertado en la posición "

+ posicion + ": ");
System.out.print(" " +
nodo.estudiante.getIdEstudiante());
System.out.print(" " + nodo.estudiante.getNombre());
System.out.print(" " +
nodo.estudiante.getApellido());
System.out.print(" " + nodo.estudiante.getEdad() +
"\n");
}

//Obtener el estudiante de la lista

public Estudiante obtener(int posicion) {
if (cabeza == null) {
return null;
} else {
//Crear un puntero apuntando a la cabeza
Nodo puntero = cabeza;
//El contador para indicar a qué numero apunta
el puntero
int contador = 0;
//El puntero recorre la lista
while (contador < posicion && puntero.siguiente
!= null) {
//El puntero apunta al siguiente
puntero = puntero.siguiente;
contador++;
}
//Si la posición solicitada es mayor al numero
de elementos
if (contador != posicion) {
return null;
} else {
//Devuelve el estudiante de la posición
requerida
return puntero.estudiante;
}
}
}

//Eliminar el primer elemento de la lista

public void eliminarInicio() {
if (cabeza != null) {
//Pimer elemento ca ser la cabeaza

6
 Nodo primero = cabeza;
//La cabeza apunta al siguiente
cabeza = cabeza.siguiente;
primero.siguiente = null;
longitud--;

//Eliminar el último elemento de la lista

public void eliminarFinal() {
if (cabeza != null) {
if (cabeza.siguiente == null) {
cabeza = null;
} else {
//Crear el puntero apuntando a la cabeza
Nodo puntero = cabeza;
//El puntero recorre la lista
while (puntero.siguiente.siguiente !=
null) {
//El punero apunta al siguiente
puntero = puntero.siguiente;
}
//Eliminamos el último elemento
puntero.siguiente = null;
longitud--;
}
}

//Eliminar elemento de una posición particular

public void eliminarPorPosicion(int posicion) {
if (cabeza != null) {
//Crear el puntero apuntando a la cabeza
Nodo puntero = cabeza;
//Crear un contador para indicar a qué número
está apuntadno el puntero
int contador = 0;
while (contador < (posicion - 1)) {
//El puntero apunta al siguiente
puntero = puntero.siguiente;
contador++;
}
Nodo temporal = puntero.siguiente;
puntero.siguiente = temporal.siguiente;
temporal.siguiente = null;
System.out.println("Se ha eliminado la posición
" + posicion + " de la lista");
longitud--;
}
}

//Lista vacía
public boolean estaVacia() {
return cabeza == null;
}

//Cantidad de elementos en la lista

public int contar() {

7
 return longitud;
}

//Imprimir lista guardada

public void imprimirLista() {
//Verifica que la lista contenga elementos
if (cabeza != null) {
//Crea un puntero apuntando a cabeza
Nodo puntero = cabeza;
//Creamos un contador para indicar a qué numero
esta apuntado cabeza
int contador = 0;
//Recorrer la lista hasta el final
System.out.println("POS
CÓDIGO\tNOMBRE\tAPELLIDO\tEDAD");
while (puntero != null) {
//Imprimir en pantalla el valor del nodo
System.out.println(contador + ".[ " +
puntero.estudiante.getIdEstudiante()
+ "\t" +
puntero.estudiante.getNombre() + "\t"
+
puntero.estudiante.getApellido() + "\t\t"
+
puntero.estudiante.getEdad() + " ]");
puntero = puntero.siguiente; //Avanzar al
siguiente nodo
contador++; //Incrementa el contador de
la posición
}
}
}

/**
* Otra Manera de imprimir incorporando el método aprendido
en teoría. While y for son equivalentes pero a diferencia del
for, while hace que sea más legible en este caso (no siendo
siempre de esta manera)
*
* @return
*/
@Override
public String toString() {
//Declaramos un variable String a la cual la
inicializaremos en vacío
String salida = "";
//Crearemos un puntero para que recorra la lista
Nodo puntero;
//Crearemos un contador para el indice de la posición
int contador = 0;
//Recorremos la lista
for (puntero = cabeza; puntero != null; puntero =
puntero.getSiguiente()) {
//Imprimimos los datos de cada elemento de la
lista
salida = salida + contador + "[ " +
puntero.estudiante.getNombre() + " ]\n";
//incremtamos en valor del contador para la
pisción
contador++;
}

8
 //Retornamos los valores leídos
return salida;
}

//Buscar elemento utilizando el ID del estudiante

public boolean buscarPorIDEstudiante(int idEstudiante) {
System.out.println("Los datos encontrados para " +
idEstudiante + " son:");
//Creamos un puntero para recorrer la lista y le
decimos que apunte a la cabeza
Nodo puntero = cabeza;
//Bandera para indicar si en ID existe
boolean encontrado = false;

//Recorrer la lista hasta encontrar elemento o se

acabe la lista
while (puntero != null && encontrado != true) {
// Consultar si el valor del nodo es igual al
ID buiscado

if (idEstudiante ==
puntero.estudiante.getIdEstudiante()) {
//Cambiar el valor de la bandera a
verdadero
encontrado = true;

System.out.println("CÓDIGO\tNOMBRE\tAPELLIDO\tEDAD");

System.out.println(puntero.estudiante.getIdEstudiante()
+ "\t" +
puntero.estudiante.getNombre() + "\t"
+
puntero.estudiante.getApellido() + "\t\t"
+
puntero.estudiante.getEdad());
} else {
//Caso contrario avanza al siguiente nodo
puntero = puntero.siguiente;
}
}
//Devolver el valor de la bandera
return encontrado;

// Insertar después de encontrar un elemento

public void insertarDespuesDeEncontrado(int IdStudent,
Estudiante estudiante) {
// Crear un nuevo nodo de estudiante
Nodo nodo = new Nodo(estudiante);
// Si la lista está vacía
if (cabeza == null) {
cabeza = nodo; //Se Agrega el nuevo nodo a la
lista vacía
} else {
// Crear un nuevo nodo "puntero" que apunta a
la cabeza
Nodo puntero = cabeza;
int ID = IdStudent;
// Hacer el recorrido mientras el id buscado
sea diferente al Id del estudiante de puntero

9
 // y el siguiente nodo de puentero sea
diferentes de null
while (ID !=
puntero.estudiante.getIdEstudiante() && puntero.siguiente !=
null) {
// Ahora puntero apunta al siguiente nodo
puntero = puntero.siguiente;
}
// Conecta por el lado derecho
nodo.siguiente = puntero.siguiente;
// Conecta por el lado izquierdo
puntero.siguiente = nodo;
}
System.out.println("Ingresando el elemento "
+ "\nCódigo: \t" +
nodo.estudiante.getIdEstudiante()
+ "\nNombre: \t" +
nodo.estudiante.getNombre()
+ "\nApellido: \t" +
nodo.estudiante.getApellido()
+ "\nEdad: \t\t" +
nodo.estudiante.getEdad());
}

//Ordenar elementos por orden alfabético de apellido

public void Ordenar() {
//Verificar que la ista tenga elementos
if (cabeza != null) {
// Designar una bandera
boolean cambio;
// Hacer el recorrido de los elementos para
compararlos
do {
// Declar nuevos para hacer la
comparación entre los nodos dentro de nuestra lista
// Nodo puntero que aputa a cabeza
Nodo puntero = cabeza;
Nodo previous = null;
// Nodo nextque apunta al siguiente nodo
de la cabeza
Nodo next = cabeza.siguiente;
// Cambiar el valor de la bandera
cambio = false;
// El nodo next asignado como el
siguiente nodo de la cabeza hace el recorrido
while (next != null) {
// Comparar los apellidos de los
nodos "puntero" y "previous"
if
(puntero.estudiante.getApellido().compareTo(next.estudiante.getAp
ellido()) > 0) {
// Cambiar el valor de la
bandera
cambio = true;
if (previous != null) {
// Crear un nuevo nodo
"sig" que apunte al nodo después de "next"
Nodo sig = next.siguiente;
// EL siguiente nodo de
"previous" ahora es "next"
previous.siguiente = next;

10
 // El nodo después de
"next" ahora es "puntero"
next.siguiente = puntero;
// El nodo después de
"puntero" ahora es "sig"
puntero.siguiente = sig;
} else {
//Declarar un nuevo
nodo que apunte al nodo siguiente de "next"
Nodo sig1 = next.siguiente;
// Ahora "cabeza" es
"netx"
cabeza = next;
// Ahora el siguiente
nodo de "next" es "puntero"
next.siguiente = puntero;
// Ahora el suiente
nodo de "puntero" es "sig1"
puntero.siguiente = sig1;
}
// Ahora "previous" es "next"
previous = next;
// ahora "next" apunta al
siguiente nodo de "puntero"
next = puntero.siguiente;
} else {
previous = puntero;
puntero = next;
next = next.siguiente;

}
}
} while (cambio);
}
}

 Y un método Main para hacer las pruebas correspondientes:

public class PruebaLista {

public static void main(String[] args) {

Lista lista = new Lista();

System.out.println("A) Agregar un elemento o elementos

al inicio de la lista");
lista.insertarInicio(new Estudiante(271388, "Sergio",
"Ramos", 23));
lista.insertarInicio(new Estudiante(271777, "Rocío",
"Richo", 19));
lista.insertarInicio(new Estudiante(271566, "Álex",
"Fuentes", 20));
lista.insertarInicio(new Estudiante(271355, "Juana",
"Pérez", 21));

11
 lista.insertarInicio(new Estudiante(271244, "Carlos",
"Suárez", 22));
lista.insertarInicio(new Estudiante(271133, "José",
"Rua", 20));
lista.insertarInicio(new Estudiante(271222, "Rosa",
"León", 22));
lista.insertarInicio(new Estudiante(271411, "Pedro",
"Quintas", 21));
System.out.println("");

System.out.println("B) Mostrar datos de nuestra Lista");

lista.imprimirLista();
System.out.println("");

System.out.println("C) Agregar un elemento al final de

la Lista");
lista.insertarFinal(new Estudiante(271199, "Aron",
"Dumas", 25));
lista.imprimirLista();
System.out.println("");

System.out.println("D) Eliminar un elemento al Inicio de

la Lista");
lista.eliminarInicio();
lista.imprimirLista();
System.out.println("");

System.out.println("E) Eliminar un elemento al Final de

la Lista");
lista.eliminarFinal();
lista.imprimirLista();
System.out.println("");

System.out.println("F) Eliminar un elemento determinado

de la lista");
lista.eliminarPorPosicion(2);
lista.imprimirLista();
System.out.println("");

System.out.println("G) Buscar un elemento en la

lista");
lista.buscarPorIDEstudiante(271777);
System.out.println("");

System.out.println("H) Ordenar la lista");

lista.Ordenar();
lista.imprimirLista();
System.out.println("");

System.out.println("I) Inserta un nuevo elemento luego

de haber encontrado un elemento en la lista");
lista.insertarDespuesDeEncontrado(271355, new
Estudiante(271356, "Carmen", "Quintas", 22));
lista.imprimirLista();

}
}

12
1.1.2 Ejercicio 3.2.2

Para la implementación de este ejercicio se mostrará algunas operaciones que se pueden hacer
al ingresar enteros positivos en una lista enlazada simple

 Para ello, primero creamos la clase Nodo correspondiente:

public class Nodo {

//Referencia a numero
Numero numero;
//referencia al siguiente nodo
Nodo siguiente = null;

//Inicializa numero
public Nodo(Numero numero) {
this.numero = numero;
}

public Numero getNumero() {

return numero;
}

public void setNumero(Numero numero) {

this.numero = numero;
}

public Nodo getSiguiente() {

return siguiente;
}

public void setSiguiente(Nodo siguiente) {

this.siguiente = siguiente;
}

 Así como la clase Numero donde se guardarán los valores ingresados:

public class Numero {

private int valor;

public void Numero(){

this.valor = 0;
}

public Numero(int valor) {

this.valor = valor;
}

public int getValor() {

return valor;
}

public void setValor(int valor) {

this.valor = valor;
}

13
 Del mismo modo todos los métodos de agregar al inicio o al final, mostrar los valores
mayor y menor de la lista, promedio de elementos y la correspondiente impresión de
estos:

public class Lista {

//Referencia a la cabeza de la lista

Nodo cabeza = null;
int dimension = 0;

//Insertar elementos al inicio de la lista

public void agregarInicio(Numero numero) {
//Crear un nuevo nodo
Nodo nodo = new Nodo(numero);
//El siguiente nodo ahora es cabeza
nodo.siguiente = cabeza;
//El nuevo nodo ahora es la cabeza
cabeza = nodo;
dimension++;
System.out.println("numero " + nodo.numero.getValor() +
" agregado correctamente");

//Mostrar elementos agregados

public void mostrarLista() {
//Verificar si la lista contentga elementos
if (cabeza != null) {
//Crear nuevo puntero apuntado a la cabeza
Nodo puntero = cabeza;
//Crear un contador para indicar a qúe posicion
apunta la cabeza
int contador = 0;
//Recorrer la lista hastael final
System.out.println("POS\tNUMERO");
while (puntero != null) {
System.out.println(contador + ".\t[ " +
puntero.numero.getValor() + " ]");
puntero = puntero.siguiente;
contador++;
}
}
}

//Agregar elementos al final de la lista

public void agregarFinal(Numero numero) {
//Creamos un nuevo nodo de estudiante
Nodo nodo = new Nodo(numero);
//Verificar si la lista esta vacía
if (cabeza == null) {
cabeza = nodo;
} else {
//Crear un puntero apuntando a la cabeza
Nodo puntero = cabeza;
//Ahora recorre la lista
while (puntero.siguiente != null) {
//Ahora puntero apunta a su siguiemte nodo

14
 puntero = puntero.siguiente;
}
//Ahora el siguiente nodo de puntero es el nodo
creado
puntero.siguiente = nodo;
}
dimension++;
System.out.print("Número " + nodo.numero.getValor());
System.out.print(" agregado correctamente al final de la
lista\n");
}

//Dar el valor mayor y menor de la lista

public void mayorYMenor() {
int aux;
Nodo puntero = cabeza;
int array[] = new int[dimension];
for (int i = 0; i < dimension; i++) {
array[i] = puntero.numero.getValor();
puntero = puntero.siguiente;
}
for (int j = 0; j < dimension; j++) {
for (int k = 0; k+1 < array.length; k++) {
if (array[j] < array[k]) {
aux = array[j];
array[j] = array[k];
array[k] = aux;
}
}
}
Lista nueva = new Lista();
for (int f = 0; f < dimension; f++) {
}
System.out.println("El mayor de los numeros es: " +
array[dimension - 1]);
System.out.println("El menos de los elemtos es: " +
array[0]);

//Calcular el promedio de los elementos de la lista

public void promedio(){
Nodo puntero = cabeza;
int suma = 0;
double promedio = 0;
while (puntero != null) {
suma = suma + puntero.numero.getValor();
puntero = puntero.siguiente;
}
promedio = suma/dimension;
System.out.println("El primedio de los valores de la
lista es: " + promedio);
}

 Y como se es debido se crea la clase Main donde se harán las pruebas

correspondientes:

15
 public class PruebalistaNumero {

public static void main(String[] args) {

Lista lista =new Lista();

System.out.println("-----Agregango elelemtos a la lista-

----");
lista.agregarInicio(new Numero(12454));
lista.agregarInicio(new Numero(15748));
lista.agregarInicio(new Numero(45456));
lista.agregarInicio(new Numero(12444));
lista.agregarInicio(new Numero(100000));
lista.agregarInicio(new Numero(1786));
lista.agregarInicio(new Numero(9999));
System.out.println("");

System.out.println("-----Mostrando elementos agregados a

la lista----- ");
lista.mostrarLista();
System.out.println("");

System.out.println("-----Agregando elemntos al final de

la lista-----");
lista.agregarFinal(new Numero(5487));
lista.mostrarLista();
System.out.println("");

System.out.println("-----Agregando más elementos al

inicio de la lista ");
lista.agregarInicio(new Numero(30303));
lista.agregarInicio(new Numero(11111));
lista.mostrarLista();
System.out.println("");

System.out.println("-----Mostrar el mayor y menor de los

elementos ingresados-----");
lista.mayorYMenor();
System.out.println("");

System.out.println("-----Hallando el promedio de la
lista ingresada-----");
lista.promedio();
System.out.println("");
}

1.2 Resultados e interpretación

1.2.1 Ejercicio 3.2.1

Al ejecutar nuestro programa para el ejercicio 3.2.1 se obtiene los siguientes resultados:

16
Ilustración 1.1: Resultado para las cuestiones A y B de ejecutar el ejercicio 3.2.1.

Ilustración 1.2: Resultado para las cuestiones C y D de ejecutar el ejercicio 3.2.1.

17
Ilustración 1.3: Resultado para las cuestiones E, F y G de ejecutar el ejercicio 3.2.1.

Ilustración 1.4: Resultado para las cuestiones H e I de ejecutar el ejercicio 3.2.1.

18
Interpretación:

 Al insertar un elemento e1 a la lista, lo que hace el método insertarInicio() es

colocarlo en la posición 0 y cuando otro elemento e2 es ingresado este primer
insertado e1 pasa a la siguiente posición (posición 1), cuando insertamos otro
más e3, este pasa a estar en la posición 0, e2 en la posición 1 y e1 en la posición
2. Esto se aplica a los siguientes eleméntenos que son ingresados. Esto puede
ser visualizado en la parte donde se muestran todos los elementos ingresados
anteriormente (Ilustración 1.1).
 Cuando se quiere insertar al final de la lista el método insertarFinal() hace que
el elemento recorra todos los nodos existentes de la lista hasta llegar al final y
posicionarse en el último, si la lista está vacía se asigna el nodo con el valor del
elemento insertado, esto se puede mostrar en la ejecución del programa
(Ilustracion1.2).
 Si se quiere eliminar el primero o el final de la lista, verificará antes si la lista
está vacía (D de la Ilustración 1.2 y E de la ilustración 1.3).
 Si se quiere eliminar un elemento determinado de la lista, recorrerá la lista en
busca de la posición que queremos eliminar hasta encontrarla (F de la
Ilustración 1.3).
 Si se desea buscar un elemento, el método buscarPorIdEstudiante() recorrerá la
lista en busca del ID en cuestión hasta encontrarlo y nos mostrará sus valores
(G de la Ilustración 1.3)
 El método Ordenar() ordena la lista por apellido alfabéticamente (H de la
Ilustración 1.4).
 Para ingresar un elemento después de otro determinado
insertarDespuesDeEncontrado() recorre toda la lista en busca del Id del
elemento que está en la lista y lo posiciona en su siguiente (I de la Ilustración
1.4).

1.2.2 Ejercicio 3.2.2

Al ejecutar nuestro programa para el ejercicio 3.2.1 se obtiene los siguientes resultados:

19
Ilustración 1.5: Resultado para las cuestiones de ejecutar el ejercicio 3.2.1.

20
Interpretación:

Como para el ejercicio anterior, este programa tiene métodos similares de agregarInicio(),
mostrarLista() o agregarFinal() que tienen la misma lógica de inserción de elementos a la
lista y métodos diferentes como mayorYMenor() para indicar el mayor y el menor de los
elementos y promedio(), que nos calcula el promedio de los elementos ingresados (Ilustración
1.5).

1.3 Repositorio

El programa está implementado en un paquete llamado TA04 (Ilustración 1.6):

Ilustración 1.6: Subida exitosa al repositorio del paquete TA04.

21
 2 CONCLUSIONES
 Se logró implementar correctamente las listas simples enlazadas.
 Se aplicó la estructura Lista para almacenar datos y valores dentro de una lista,
esto está reflejado cuando se quiere imprimir la lista.
 Se logró aprender a definir y manipular estructuras de listas simples enlazadas.
 Se logró realizar las operaciones con listas simples enlazadas, esto gracias a la
implementación de métodos que almacenan y hacen recorridos dentro de la lista.

22