387 Cómo se discurre antes del matrimonio.

Suponiendo que
ella me ame, ½cómo me importunará a la larga! y suponiendo que
no me ame, ½cómo no ha de tener mayores razones todavía para
Universidad Simón Bolívar volverse importuna a la larga! No hay en esta disyuntiva más que
Departamento de Computación dos maneras de ser importuno. ½Casémonos, pues!
y Tecnología de la Información
Laboratorio de Computación II Aurora, Federico Nietzsche.
Sep-Dic 2018

Lab. 7Sem. 10Tad Conjunto y Tad Iterador de Conjunto.

struct
En este laboratorio primero se escribirán los algoritmos necesarios para implementar el tipo abstracto de
datos Conjunto usando un que contiene el tamaño actual del conjunto, el tamaño máximo del mis-
mo y un apuntador a un arreglo de enteros donde se almacenan los elementos del conjunto. Finalmente se
presentará el tipo Iterador para el tipo Conjunto.

Tareas

1. Copie y pruebe le siguiente código:

#include <stdio.h>
#include <stdlib.h>

///Modelo de representación.
///Un Conjunto será un apuntador a un Conj
///que es un registro con tres campos que representan
///el tamaño máximo del conjunto---su capacidad---,
///un arreglo a de tamaño MAX, y el número de elementos
///sctualmente en el conjunto.

typedef struct conj {

int MAX;
int* a;
int tam;
} Conj;

typedef Conj* Conjunto;

///Invariante de representación:
///tam < MAX ....

///Constructor de un Conjunto vacío

///Pre: max_tam > 0

Conjunto newConjunto(int max_tam){
Conjunto c = malloc(sizeof(Conj));
c->tam = 0;
c->MAX = max_tam;
c->a = malloc(max_tam*sizeof(int));
return c;
}

///Oservadores:

///Pre: True = Ninguna

int esVacio(Conjunto c){ return c->tam == 0; }
 int pertenece(int x, Conjunto c){
int k = 0;
while(k < c->tam && x != (c->a)[k]) k++;
return k < c->tam;
}

int card(Conjunto c){ return c->tam; }

void escribeConjunto(Conjunto c, char* name){

printf("\n%s = {", name);
int k = 0;
while(k < c->tam -1) printf("%d, ", (c->a)[k++]);
printf("%d}", (c->a)[k]);
}

void reSize(Conjunto c){

int newSize = 1.3*c->MAX +1, k = 0;
int * b = malloc(newSize*sizeof(int));
while(k < c->tam) b[k] = c->a[k++];
c->MAX = newSize;
free(c->a);
c->a = b;
}

///Pre: True El mecanismo de agregar asegura que siempre tam < MAX
void agregar(int x, Conjunto c){
int k = 0;
while(k<c->tam && x != (c->a)[k]) k++;
if(k >= c->tam) (c->a)[(c->tam)++] = x;
if(c->tam == c->MAX) reSize(c);
}

///Pre: True
void remover(int x, Conjunto c){
int k = 0;
while(k < c->tam && x != (c->a)[k]) k++;
if(k < c->tam) (c->a)[k] = (c->a)[--(c->tam)];
}

2. Copiar el Tipo Iterador: Iterador para Conjuntos

///Modelo de representación
typedef struct ite {
Conjunto t;
int ind;
} Ite;

typedef Ite* Iter;

///Constructor y métodos---más bien funciones

Iter newIter(Conjunto c){
Iter i = malloc(sizeof(Ite));
i->t = c; i->ind = 0;
return i;
}
 int hasNext(Iter i){
return i->ind < (i->t)->tam;
}

int next(Iter i){

return ((i->t)->a)[(i->ind)++];
}

3. Una pequeña mustra del uso del tipo Iterador de Conjuntos:

///Pre: True; retorna la interseccion de a con b
Conjunto interset(Conjunto a, Conjunto b){
int ca = card(a), cb = card(b), e;
Conjunto c;
if(ca < cb) c = newConjunto(ca);
else c = newConjunto(cb);
Iter i = newIter(a);
while(hasNext(i)){
e = next(i); ///Tomo un elemento de A
if(pertenece(e, b)) agregar(e,c);
}
return c;
}

int main(){///
Conjunto b = newConjunto(2), a = newConjunto(6);
agregar(5, b); agregar(7, b); agregar(9, b); agregar(7, b);
agregar(5, a); agregar(8, a); agregar(7, a); agregar(3, a);
Iter i = newIter(b);
while(hasNext(i)) printf("\nelemento %d", next(i));
printf("\nb tiene %d elementos.", card(b));
escribeConjunto(b, "b");
Conjunto c = interset(a, b);
escribeConjunto(c, "c");
if(subseteq(c,b)) printf("\nc es subset b");
printf("\nMision cumPlida!!!\n");
return 0;
}

4. Complete las las siguientes funciones: En esta parte sólo puede usar las funciones del tipo vistas con
anterioridad y las del tipo iterador. No puede usar la representación interna del tipo. Tome como
referencia el ejemplo hecho en la función interset del ejercicio anterior.

///Pre: True; Retorna los elementos de a que no están en b

Conjunto differ(Conjunto a, Conjunto b){
Conjunto c;
///Completar...
return c;
}

///Pre: True; Retorna el conjunto de los elementso que están en a o en b

Conjunto unir(Conjunto a, Conjunto b){
Conjunto c;
 ///Completar...
return c;
}

///
int subseteq(Conjunto a, Conjunto b){
Iter i = newIter(a); int e;
while(hasNext(i)){
e = next(i);
///Completar...
}
return 1;
}

int equals(Conjunto a, Conjunto b){

5. Librería Conjunto.h Forme una librería en la que coloque las funciones básicas del tipo conjunto y su
iterador.

Nota: Se recomienda seriamente que no se hagan cut and paste. Debe copiar su código para que
lo entienda mejor!!!