ESCUELA SUPERIOR POLITÉCNICA DE CHIMBORAZO

FACULTAD: INFORMÁTICA Y ELECTRÓNICA

ESCUELA DE INGENIERÍA EN SISTEMAS
CARRERA: SOFTWARE

GUÍA DE LABORATORIO DE ESTRUCTURAS DE DATOS

PRÁCTICA No. 02 –

1. DATOS GENERALES:

NOMBRE DEL ESTUDIANTE CODIGO DEL ESTUDIANTE

SHIRLEY EDIZA CHELA LLUIGUANO 7322

FECHA DE REALIZACIÓN: FECHA DE ENTREGA:

2023/12/20 2023/12/21

2. OBJETIVO(S):

2.1. GENERAL
Desarrollar un programa en C++ que utilice listas enlazadas para encontrar y almacenar los
valores más cercanos a cada elemento de una lista dada.

2.2. ESPECÍFÍCOS

• Implementar funciones recursivas para acceder y procesar los elementos de la lista enlazada.

• Utilizar punteros y referencias para gestionar eficientemente la memoria y los datos.

• Demostrar el uso de prototipos de funciones para mejorar la modularidad del código.

3. METODOLOGÍA
La metodología utilizada en el desarrollo de este programa sigue los principios de
programación modular y orientada a objetos. Se ha enfocado en la implementación de
funciones especializadas para realizar tareas específicas, promoviendo la reutilización de
código y facilitando el mantenimiento. El uso de listas enlazadas y recursividad se
 seleccionó para abordar de manera eficiente la manipulación de datos y la resolución del
problema planteado.

4. EQUIPOS Y MATERIALES:

- Computador
- Entorno integrado de desarrollo (IDE)
- Aula virtual
- Acceso a internet
- Bibliografía

5. MARCO TEORICO:
Para comprender mejor el funcionamiento del programa, es necesario revisar algunos
conceptos clave relacionados con listas enlazadas y recursividad:

Listas Enlazadas:
Las listas enlazadas son estructuras de datos dinámicas que consisten en nodos conectados,
donde cada nodo contiene un valor y una referencia al siguiente nodo. Esto permite una
gestión eficiente de la memoria y la manipulación de datos.

Nodos y Conexiones:

Nodo: En una lista enlazada, cada elemento se almacena en un nodo. Cada nodo contiene
dos campos principales: el dato que guarda la información específica y un puntero que apunta
al siguiente nodo en la secuencia.
Conexiones: Estos nodos están vinculados mediante punteros, formando una cadena o
secuencia. El último nodo generalmente apunta a NULL, indicando el final de la lista.

Recursividad:
La recursividad es una técnica de programación en la que una función se llama a sí misma
para abordar un problema. En este programa, las funciones como ingresarLista, imprimirLista,
y otras, utilizan la recursividad para manipular los elementos de las listas de manera eficiente.
La recursividad en C++ se basa en la idea de que un problema se puede dividir en casos más
pequeños y manejables hasta llegar a un caso base, que es la instancia más simple del
problema y no requiere una llamada recursiva para su resolución.

Funciones y Prototipos:
Los prototipos de funciones permiten al compilador conocer la firma de una función antes de
su implementación, lo que facilita la llamada a funciones antes de que estén definidas en el
código. Este enfoque mejora la modularidad del código.

Punteros y Referencias:
El uso de punteros y referencias en C++ es esencial para trabajar con estructuras de datos
dinámicas como las listas enlazadas. Facilitan la manipulación de datos y la navegación a
través de la estructura.
Punteros:
Almacenamiento de Direcciones: Permiten almacenar direcciones de memoria, crucial para
gestionar estructuras dinámicas como nodos en una lista enlazada.

Navegación a Través de la Lista: Facilitan la navegación a través de la lista, ya que un puntero

puede seguir la secuencia de nodos.

Referencias:

Acceso Directo a Datos: Proporcionan una forma de acceder y manipular directamente el

valor almacenado en una posición de memoria, sin manipular direcciones de memoria.

Facilidad de Lectura: Su uso mejora la legibilidad del código al proporcionar una sintaxis más
limpia y fácil de entender.

6. PROCEDIMIENTO:
El código es un programa en C++ que realiza diversas operaciones con listas enlazadas. A
continuación, se detalla el procedimiento general del programa:

Inclusión de Librerías y Definiciones:

Se incluyen las librerías necesarias, como iostream y Lista1.h.

Se define un valor constante FIN que se utiliza para indicar el fin de la entrada de datos.

Prototipos de Funciones:

Se declaran los prototipos de funciones que se utilizarán más adelante en el programa, para
poder cumplir con el objetivo del programa.

Función Principal (main):

Se crea una instancia de las clases Lista llamadas l1 y l2.

Se invoca la función ingresarLista para que el usuario ingrese valores a la lista l1.
Se llama a la función encontrarYAlmacenarCercanos para procesar la lista l1 y almacenar los
valores más cercanos en la lista l2.
Se imprime la lista original l1 y la lista de valores más cercanos l2.
Se utiliza la función system("pause") para pausar la ejecución y visualizar los resultados.

Función ingresarLista:

Recursivamente solicita al usuario que ingrese valores para la lista l1 hasta que se ingrese el
valor FIN.
Inserta cada valor al final de la lista l1.

Función imprimirLista:

Recursivamente imprime los elementos de una lista enlazada dada.

Función obtenerValor:
Recursivamente obtiene el valor en la posición N de una lista enlazada dada.
Verificar si el nodo es nulo o si N es menor que 0.
Si N es 0, devolver el dato del nodo actual.
Llamar recursivamente a obtenerValor con el siguiente nodo y decrementar N.

Función encontrarYAlmacenarCercanos:

Llama a la función procesarLista para iniciar el procesamiento de la lista original y encontrar

los valores más cercanos.

Función procesarLista:

Procesa la lista original, llamando a la función encontrarCercano para cada nodo.

Inserta en la lista de valores cercanos (cercanos) el valor más cercano encontrado para cada
nodo.

Función encontrarCercano:

Encuentra el valor más cercano a un nodo dado (nodoActual) comparando con cada nodo en
la lista original.
Calcula la diferencia absoluta y actualiza el valor más cercano y la diferencia mínima.
En resumen, el programa realiza la manipulación de listas enlazadas para encontrar y
almacenar los valores más cercanos a cada elemento de la lista original, utilizando funciones
recursivas para acceder y procesar los elementos de la lista.

Dada toda la lógica y la implementación de las funciones procedemos a realizar pruebas para
ver si el programa no marca errores y si cumple con lo solicitado y ahí mirar su eficiencia.

7. CONCLUSIONES Y RECOMENDACIONES:

• El programa logra cumplir su objetivo al encontrar y almacenar los valores más

cercanos a cada elemento de la lista original.

• La implementación de listas enlazadas y funciones recursivas permite un manejo

eficiente de los datos, facilitando la manipulación de la información.

• El código demuestra un buen uso de buenas prácticas de programación, como la

modularidad mediante funciones y la utilización de prototipos.

Recomendaciones:
• Se sugiere mejorar la interacción con el usuario proporcionando información
adicional durante la ejecución del programa, como mensajes que indiquen el
progreso o el propósito de cada parte del programa.
 • Podría considerarse la implementación de mecanismos de manejo de errores para
abordar posibles situaciones en las que el usuario ingrese datos incorrectos o
inesperados.

• Sería beneficioso documentar el código de manera más extensa, incluyendo

comentarios que expliquen el propósito de las funciones y secciones clave del
programa.

8. BIBLIOGRAFÍA:

• Deitel, H. M., Deitel, P. J. (1995). Cómo programar en C/C+. Argentina: Prentice Hall
Hispanoamericana.

• Deitel, H. M., Deitel, P. J. (2003). C++ how to Program. Reino Unido: Prentice Hall.

• Garrido Carrillo, A. (2005). Fundamentos de Programación en C++. España: Delta

Publicaciones.

ANEXOS (adjuntar el código fuente del programa/módulo desarrollado)

using namespace std;

#include <iostream>
#include <climits>
#include<cmath>
#include "Lista1.h" // Incluye la definición de la clase Lista y Nodo.
#define FIN 9999 // Valor utilizado para indicar el fin de la entrada de datos.

// Prototipos de funciones.
void ingresarLista(Lista *l1);
void imprimirLista(Nodo *act);
Tipo obtenerValor(Nodo *nodo, int N);
void encontrarYAlmacenarCercanos(Lista *original, Lista *cercanos);
void procesarLista(Nodo *nodoActual, Lista *original, Lista *cercanos);
void encontrarCercano(Nodo *nodo, Tipo valorNesimo, Nodo *nodoActual, Tipo
&valorMasCercano, int &diferenciaMinima);

int main()
{
system("color 0B");
setlocale(LC_ALL,"");
Lista l1, l2;

ingresarLista(&l1);
encontrarYAlmacenarCercanos(&l1, &l2);

cout << "---------------Lista Original------------- "<< endl;

 imprimirLista(l1.getPrimero());

cout << "------------Lista de Valores Mas Cercanos------------ "<< endl;

imprimirLista(l2.getPrimero());
cout<< endl;
system("pause");
}

void ingresarLista(Lista *l1)

{
Tipo aux;
cout << "Ingrese un valor para poner en la lista..........FINALICE CON [" << FIN << "]: ";
cin >> aux;

if (aux != FIN)
{
l1->insertarAlFinal(aux);
ingresarLista(l1);
}
}

void imprimirLista(Nodo *act)

{
if (act != NULL)
{
cout << act->getDato() << endl;
imprimirLista(act->getPunt());
}
}

Tipo obtenerValor(Nodo *nodo, int N)

{
if (nodo == NULL || N < 0)
{
return -1;
}
if (N == 0)
{
return nodo->getDato();
}
return obtenerValor(nodo->getPunt(), N - 1);
}

void encontrarYAlmacenarCercanos(Lista *original, Lista *cercanos)

{
procesarLista(original->getPrimero(), original, cercanos);
}
void procesarLista(Nodo *nodoActual, Lista *original, Lista *cercanos)
{
if (nodoActual == NULL)
{
return;
}

Tipo valorMasCercano = INT_MAX;

int diferenciaMinima = INT_MAX;

encontrarCercano(original->getPrimero(), nodoActual->getDato(), nodoActual,

valorMasCercano, diferenciaMinima);

if (diferenciaMinima != INT_MAX)
{
cercanos->insertarAlFinal(valorMasCercano);
}
else
{
cercanos->insertarAlFinal(nodoActual->getDato());
}

procesarLista(nodoActual->getPunt(), original, cercanos);

}

void encontrarCercano(Nodo *nodo, Tipo valorNesimo, Nodo *nodoActual, Tipo

&valorMasCercano, int &diferenciaMinima)
{
if (nodo == NULL)
{
return;
}

if (nodo != nodoActual)
{
int diferenciaActual = abs(nodo->getDato() - valorNesimo);
if (diferenciaActual < diferenciaMinima)
{
diferenciaMinima = diferenciaActual;
valorMasCercano = nodo->getDato();
}
}

encontrarCercano(nodo->getPunt(), valorNesimo, nodoActual, valorMasCercano,

diferenciaMinima);
}