ESTRUCTURAS DE DATOS Y ALGORITMOS

1º de Grado en Ingeniería Informática

(Curso 2017-2018)
PRÁCTICA 2

1. NORMAS GENERALES
1. La práctica deberá realizarse en grupo. El grupo estará formado por dos
alumnos del mismo grupo de laboratorio.
2. Se valorará la modularidad, calidad y legibilidad del código, el uso apropiado
de estructuras y la inclusión de comentarios.
3. La práctica deberá realizarse sobre la plantilla proporcionada. Deberá
rellenarse el fichero Autores.xls con los datos de los autores.
4. La entrega de la práctica se realizará a través de la tarea habilitada en el Aula
Virtual, hasta el 18 de Marzo (inclusive). Está práctica deberá ser aprobada
para poder superar la asignatura. La subida a Moodle deberá realizarse
únicamente por uno de los alumnos del grupo.
5. Se deberá subir únicamente un fichero *.rar, nombrado del siguiente modo:
PR2_Nombre1Apellido1_Nombre2Apellido2.rar (Ejemplo:
PR2_AntonioPerez_JulianLopez. rar). El nombre y el apellido del alumno
no deberá contener acentos.
6. El fichero *.rar contendrá un fichero Excel con los datos de los autores y los
ficheros fuente de las partes 1, 2 y 3 de esta práctica, nombrados siguiente
modo: PR2_Autores.xls, PR2_P1_Nombre1Apellido1_Nombre2Apellido2.c,
PR2_P2_Nombre1Apellido1_Nombre2Apellido2.c y
PR2_P3_Nombre1Apellido1_Nombre2Apellido2.c (Ejemplo: Autores.xls,
PR2_P1_AntonioPerez_JulianLopez.c,
PR2_P2_AntonioPerez_JulianLopez.c ,
PR2_P3_AntonioPerez_JulianLopez.c). En el nombre de los ficheros
fuente, el nombre y apellido del alumno no deberán contener acentos.
7. Aquellas entregas que no cumplan la normativa de nombrado de entrega
(nombre de ficheros, archivos a incluir) se calificarán con 0 puntos.

1
 8. Los profesores de la asignatura podrán seleccionar un conjunto de
alumnos a los que se les realizarán diversas cuestiones sobre su práctica
de forma presencial con el fin de decidir su calificación definitiva en la
práctica.
2. OBJETIVOS
 Uso de conjuntos y sus operaciones básicas.
 Utilización de pilas y colas y sus operaciones básicas.
3. ENUNCIADO
3.1. Primera parte: uso de conjuntos y sus operaciones básicas.
Esta práctica consiste en leer un archivo de texto que contiene varios conjuntos,
calcular el resultado de aplicar sobre ellos una serie de operaciones y almacenarlos en un
archivo de texto. Para ello, deberán implementarse algunas operaciones básicas sobre
conjuntos.

El programa deberá presentar al usuario el siguiente menú:

1. A Union B; A Union C; B Union C. Esta opción mostrará por pantalla el

resultado de cada una de las operaciones.
2. A Interseccion B; A Interseccion C; B Interseccion C. Esta opción mostrará
por pantalla el resultado de cada una de las operaciones.
3. A - B; A - C; B - C. Esta opción mostrará por pantalla el resultado de cada una
de las operaciones.
4. Complementario (A); Complementario(B); Complementario(C). Esta opción
mostrará por pantalla el resultado de cada una de las operaciones.
5. (A Interseccion B ) Union Complementario (( B Interseccion C )). Esta
opción mostrará por pantalla el resultado de cada una de las operaciones.
6. Crear conjunto vacio. Esta opción mostrará por pantalla el conjunto vacio.
7. Anadir elemento. Esta opción permitirá añadir un elemento a un conjunto. El
programa solicitará al usuario el nombre del conjunto donde se desea añadir el
elemento y el elemento a añadir. Deberá comprobarse que:
 El conjunto es A, B, o C.
 El elemento que el usuario desea añadir no está ya incluido dentro del
conjunto.

2
  El elemento es correcto, es decir, pertenece al conjunto universal, los
números primos dentro del intervalo (0, 100).
Si no se cumple alguna de estas condiciones se indicará al usuario.
8. Quitar elemento. Esta opción permitirá eliminar un elemento de un conjunto. El
programa solicitará al usuario el nombre del conjunto donde se desea eliminar el
elemento y el elemento a eliminar. Deberá comprobarse que:
 El conjunto es A, B, o C.
 El elemento que el usuario desea añadir está incluido en el conjunto.
 El elemento es correcto, es decir, pertenece al conjunto universal, los
números primos dentro del intervalo (0, 100).
Si no se cumple alguna de estas condiciones se indicará al usuario.
9. Crear conjunto unitario. Esta opción permitirá crear un conjunto unitario.
Deberá comprobarse que:
 El elemento es correcto, es decir, pertenece al conjunto universal, los
números primos dentro del intervalo (0, 100).
Si no se cumple esta condición se indicará al usuario.
10. Comprobar existencia. Esta opción permitirá comprobar la existencia de un
elemento en un conjunto. El programa solicitará al usuario el nombre del
conjunto donde se desea comprobar la existencia del elemento y el elemento.
Se indicará al usuario si el elemento existe o no en el conjunto. Deberá
comprobarse que:
 El conjunto es A, B, o C.
 El elemento es correcto, es decir, pertenece al conjunto universal,
los números primos dentro del intervalo (0, 100).
Si no se cumple alguna de estas condiciones se indicará al usuario.
11. Calcular cardinal de conjunto. Esta opción permitirá calcular el número de
elementos de un conjunto. El programa solicitará al usuario el nombre del
conjunto cuyo número de elementos se desea calcular. Se indicará al usuario
el cardinal del conjunto. Deberá comprobarse que:
 El conjunto es A, B, o C.

12. Salir.

3
 Cualquier otra opción que el usuario introduzca se considerará inválida y
se deberá volver a mostrar el menú.
Si el alumno decide realizar la parte opcional de esta práctica, descripta en
el apartado 3.1.3, deberá implementar la siguiente opción:

13. Almacenar los resultados de las opciones 1, 2, 3, 4 y 5 en un archivo. Esta

opción funcionará según lo indicado en el 3.1.3.

3.1.1. Lectura de un archivo y almacenamiento interno

Se proporciona un archivo de texto “Conjuntos.txt” donde cada fila representa un

conjunto y los elementos que este incluye. Un elemento es un número primo. Cada fila
del archivo es de la forma:

<NOMBRE DEL CONJUNTO>; <ELEMENTO1>;<ELEMENTO2>;…;<ELEMENTON>

<NOMBRE DEL CONJUNTO>: Cadena de caracteres que identifica al conjunto.

<ELEMENTO1>: Número primo.
<ELEMENTO2>: Número primo.
.
.
.
<ELEMENTON>: Número primo.

Este apartado de la práctica consistirá en leer del archivo de texto toda la información y
almacenarla en el siguiente registro.

tConjunto Conjuntos[MAX_CONJUNTOS];

typedef struct {
char Nombre[MAX_NOMBRE_CONJUNTO];
short int Elementos[N];
short int Ultimo;
} tConjunto;

3.1.2. Operaciones básicas sobre conjuntos

4
 Este apartado de la práctica consiste en implementar en C las siguientes
operaciones sobre conjuntos, cuyos prototipos se proporcionan a continuación:
/* Función: IniCjtos
* Inicializa la variable que guardará los conjuntos que se leerán
* del fichero.
* Parámetros de entrada:
* no tiene
* Precondiciones:
* no tiene
* Parámetros de salida:
* Conjuntos. Valor devuelto por referencia.
*/

void IniCjtos (tConjunto *Conjuntos);

/* Función: LeeFichero
* Lee un fichero con la información de los conjuntos y almacena la
* información.
* Parámetros de entrada:
* Nombre de fichero.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Conjuntos. Valor devuelto por referencia.
* Resultado de la operación. Valor devuelto por la función.
*/

int LeeFichero (char *NomFichero, tConjunto *Conjuntos);

/* Función: CjtoVacio
* Construye un conjunto vacio.
* Parámetros de entrada:
* no tiene.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Conjunto. Valor devuelto por la función.
*/

tConjunto CjtoVacio (void);

/* Función: Aniadir
* Añade un elemento a un conjunto.Comprueba que el elemento pertenece al
*conjunto universal, es decir es un número primo ubicado en el intervalo
*(0, 100). El elemento que se añada se situa a continuación del último
*elemento del conjunto.
* Parámetros de entrada:
* Elemento a añadir.
* Conjunto al que se desea añadir el elemento.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Conjunto. Valor devuelto por la función.
*/

tConjunto Aniadir (short int Elemento, tConjunto X);

/* Función: Quitar
* Quita un elemento a un conjunto. Para llenar el hueco que se deja al
* quitar un elemento, colocará allí el último elemento.
* Parámetros de entrada:
* Elemento a quitar.
* Conjunto al que se desea quitar el elemento.
* Precondiciones:
* no tiene
* Parámetros de salida:

5
* Conjunto. Valor devuelto por la función.
*/

tConjunto Quitar (short int Elemento, tConjunto X);

/* Función: Unit
* Construye un conjunto unitario. La función omprueba que el elemento
* pertenece al conjunto universal, es decir es un número primo ubicado
* en el intervalo (0, 100).
* Parámetros de entrada:
* Elemento del conjunto.
* Conjunto al que se desea quitar el elemento.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Conjunto unitario. Valor devuelto por la función.
*/

tConjunto Unit (short int Elemento);

/* Función: Esta
* Comprueba si un elemento está en un conjunto.
* Parámetros de entrada:
* Elemento cuya existencia se va a comprobar.
* Conjunto donde se chequea la existencia del elemento.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Si existe o no en el conjunto. Valor devuelto por la función.
*/

tBoolean Esta (short int Elemento, tConjunto C);

/* Función: EsCjtoVacio
* Comprueba si un conjunto está vacio.
* Parámetros de entrada:
* Conjunto.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Si está vacio o no. Valor devuelto por la función.
*/

tBoolean EsCjtoVacio (tConjunto C);

/* Función: Union
* Realiza la unión de dos conjuntos y devuelve el resultado.
* Parámetros de entrada:
* Conjunto X.
* Conjunto Y.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Conjunto resultante de la unión. Valor devuelto por la función.
*/

tConjunto Union (tConjunto X, tConjunto Y);

/* Función: Intersección
* Realiza la intersección de dos conjuntos y devuelve el resultado.
* Parámetros de entrada:
* Conjunto X.
* Conjunto Y.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Conjunto resultante de la intersección. Valor devuelto por la función.
*/

tConjunto Interseccion(tConjunto X, tConjunto Y);

6
/* Función: Complementario
* Obtiene el complementario de un conjunto y devuelve el resultado.
* Parámetros de entrada:
* Conjunto.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Conjunto complementario. Valor devuelto por la función.
*/

tConjunto Complementario (tConjunto X);

/* Función: Diferencia
* Realiza la diferencia de dos conjuntos y devuelve el resultado.
* Parámetros de entrada:
* Conjunto X.
* Conjunto Y.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Conjunto resultante de la diferencia. Valor devuelto por la función.
*/

tConjunto Diferencia (tConjunto X, tConjunto Y);

/* Función: ImprimeCjto
* Imprime el conjunto que se le pasa como parámetro, en la salida
standard o en un fichero.
* Parámetros de entrada:
* Conjunto.
* Valor que indica si se escribe en la salida stardard (FALSE) o en un
* fichero (TRUE).
* Precondiciones:
* no tiene
* Parámetros de salida:
* no tiene.
*/

void ImprimeCjto (tConjunto C, tBoolean);

/* Función: CalcCjtoV
* Obtiene el conjunto universal.
* Parámetros de entrada:
* no tiene.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Conjunto universal. Valor devuelto por la función.
*/

tConjunto CalcCjtoV (void);

/* Función: CalcCardinal
* Obtiene el cardinal del conjunto que se le pasa como parámetro.
* Parámetros de entrada:
* Conjunto.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Cardinal. Valor devuelto por la función.
*/

int CalcCardinal(tConjunto C);

/* Función: AlmOpe
* Almacena las operaciones 1 a 5 en un archivo.
* Parámetros de entrada:
* Conjunto.

7
 * Precondiciones:
* no tiene
* Parámetros de salida:
* no tiene.
*/

void AlmOpe(tConjunto Cjtos[MAX_CONJUNTOS]);

3.1.3. Almacenar resultados en un archivo (Opcional)

Esta apartado de la práctica es opcional, y consiste en realizar lo indicado a

continuación.
Una vez se hayan definido cada una de las operaciones anteriores, éstas deberán
utilizarse tal y como se indica a continuación. Sean los conjuntos A, B y C proporcionados en
el archivo “conjuntos.txt”. Realizar las siguientes operaciones:

Por último, almacenar en un archivo de nombre “Resultado.txt”, además de los

conjuntos originales (A, B, C), el resultado de cada una de las operaciones anteriores (una por
fila), utilizando un nombre representativo para cada una. La representación del resultado
deberá ser idéntica a la utilizada a lo largo de la práctica (conjuntos.txt). Cada línea de este
fichero será de la forma:
<NOMBRE OPERACIÓN i>={<ELEMENTO1>,<ELEMENTO2>,…,<ELEMENTON>}

<NOMBRE OPERACIÓN i>: Cadena de caracteres que identifica la operación.

<ELEMENTO1>: Número primo.
<ELEMENTO2>: Número primo.
.
.
.
<ELEMENTON>: Número primo.

Por ejemplo, para la operación

AunionB={29,31,37,41,43,47}

8
 3.2. Segunda parte: Utilización de pilas y sus operaciones básicas.
Diseñar y codificar en C un programa que muestre por la salida estándar un menú con
las siguientes opciones:

MENU
1. Llenar pila.
2. Sumar elementos pila.
3. Salir

La pila deberá implementarse y manejarse utilizando memoria dinámica.

Se describe a continuación la funcionalidad de cada una de estas opciones:

1. Llenar pila. Puebla la pila con 20 números reales generados aleatoriamente en el

intervalo [0, 20]. Una vez poblada la pila, se escribe en la salida estándar el valor de los
elementos de la pila.
2. Sumar elementos pila. El programa solicitará al usuario el número de
elementos a extraer de la pila, mostrará por pantalla el contenido de la pila y la
suma de los elementos extraídos. Si se solicita extraer más elementos que los
contenidos en la pila, se extraerán todos los posibles.
3. Salir del programa. La aplicación muestra el mensaje "Adiós." y finaliza.

Se deberán implementar al menos las siguientes funciones:

/* Función: AsignarMemoria
* Devuelve memoria apara un puntero a *tPila.
* Parámetros de entrada:
* no tiene
* Precondiciones:
* no tiene
* Parámetros de salida:
* Memoria para un puntero a *tPila. Valor devuelto por la función.
*/

tPila **AsignarMemoria(void);
/* Función: Apilar
* Devuelve el resultado de la operación (correcto o error).
* Parámetros de entrada:
* Elemento añadir a la pila.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Pila. Valor devuelto por referencia.
* Resultado de la operación. Valor devuelto por la función.
*/

int Apilar(tPila **p, float E);

/* Función: Desapilar
* Devuelve el resultado de la operación (correcto o error).
* Parámetros de entrada:

9
* Elemento añadir a la pila.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Pila. Valor devuelto por referencia.
* Elemento desapilado. Valor devuelto por referencia.
* Resultado de la operación. Valor devuelto por la función.
*/

int Desapilar(tPila **p, float *E);

/* Función: VerPila
* Devuelve el resultado de la operación (correcto o error).
* Parámetros de entrada:
* Pila
* Precondiciones:
* no tiene
* Parámetros de salida:
* no tiene
* Resultado de la operación. Valor devuelto por la función.
*/

int VerPila(tPila *p);

/* Función: LlenarPila
* Devuelve el resultado de la operación (correcto o error).
* Parámetros de entrada:
* Número de elementos a incluir.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Pila. Valor devuelto por referencia.
* Resultado de la operación. Valor devuelto por la función.
*/

int LlenarPila (tPila **p, int N);

/* Función: Menu
* Devuelve la opción de menú escogida.
* Parámetros de entrada:
* no tiene.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Opción de menú escogida. Valor devuelto por la función.
*/

int Menu (void);

/* Función: Sumar
* Extrae de la pila un número de elementos, y devuelve su suma. También
* devuelve el resultado de la operación.
* Parámetros de entrada:
* no tiene.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Suma. Valor devuelto por referencia.
* Resultado de la operación. Valor devuelto por la función.
*/

int Sumar (tPila **p, int N, float *Sum);

3.3. Tercera parte: Utilización de colas y sus operaciones básicas.

10
Diseñar y codificar en C un programa que muestre por la salida estándar un menú con
las siguientes opciones:

MENU
1. Llenar cola.
2. Sumar elementos cola.
3. Salir

La cola deberá implementarse y manejarse utilizando memoria dinámica.

Se describe a continuación la funcionalidad de cada una de estas opciones:

4. Llenar cola. Puebla la cola con 20 números reales generados aleatoriamente en el

intervalo [0, 20]. Una vez poblada la cola, se escribe en la salida estándar el valor de los
elementos de la cola.
5. Sumar elementos cola. El programa solicitará al usuario el número de
elementos a extraer de la cola, mostrará por pantalla el contenido de la cola y la
suma de los elementos extraídos. Si se solicita extraer más elementos que los
contenidos en la cola, se extraerán todos los posibles.
6. Salir del programa. La aplicación muestra el mensaje "Adiós." y finaliza.

Se deberán implementar al menos las siguientes funciones:

/* Función: AsignarMemoria
* Devuelve memoria apara un puntero a *tCola.
* Parámetros de entrada:
* no tiene
* Precondiciones:
* no tiene
* Parámetros de salida:
* Memoria para un puntero a *Cola. Valor devuelto por la función.
*/

tCola *AsignarMemoria(void);
/* Función: Encolar
* Devuelve el resultado de la operación (correcto o error).
* Parámetros de entrada:
* Elemento añadir a la cola.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Cola. Valor devuelto por referencia.
* Resultado de la operación. Valor devuelto por la función.
*/

int Encolar (tCola **p, float E);

/* Función: Desencolar
* Devuelve el resultado de la operación (correcto o error).
* Parámetros de entrada:
* Elemento añadir a la cola.

11
* Precondiciones:
* no tiene
* Parámetros de salida:
* Cola. Valor devuelto por referencia.
* Elemento desapilado. Valor devuelto por referencia.
* Resultado de la operación. Valor devuelto por la función.
*/

int Desencolar (tCola **p, float *E);

/* Función: VerCola
* Devuelve el resultado de la operación (correcto o error).
* Parámetros de entrada:
* Cola
* Precondiciones:
* no tiene
* Parámetros de salida:
* no tiene
* Resultado de la operación. Valor devuelto por la función.
*/

int VerCola (tCola *p);

/* Función: LlenarCola
* Devuelve el resultado de la operación (correcto o error).
* Parámetros de entrada:
* Número de elementos a incluir.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Cola. Valor devuelto por referencia.
* Resultado de la operación. Valor devuelto por la función.
*/

int LlenarCola (tCola **p, int N);

/* Función: Menu
* Devuelve la opción de menú escogida.
* Parámetros de entrada:
* no tiene.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Opción de menú escogida. Valor devuelto por la función.
*/

int Menu (void);

/* Función: Sumar
* Extrae de la cola un número de elementos, y devuelve su suma. También
* devuelve el resultado de la operación.
* Parámetros de entrada:
* no tiene.
* Precondiciones:
* no tiene
* Parámetros de salida:
* Suma. Valor devuelto por referencia.
* Resultado de la operación. Valor devuelto por la función.
*/

int Sumar (tCola **p, int N, float *Sum);

4. MATERIAL ADICIONAL

12
Se proporcionan los siguientes archivos, tal y como se ha explicado en el enunciado:

 PR2_Plantilla_Parte1.c
 conjuntos.txt
 PR2_Plantilla_Parte2.c
 PR2_Plantilla_Parte3.c
 Autores.xlsx

Queda prohibida la difusión de este material y de cualquier

parte de su contenido fuera del ámbito de la UFV.

13