Nombre y Apellidos:

___________________________________

DNI:
___________________________________

EJERCICIO 1 (5 puntos)
Se quiere implementar una clase de multiconjuntos que extienda la interfaz Set<E> y se estn barajando varias
opciones para el rea de datos.
Opcin 1: LinkedList<E> data;
Opcin 2: LinkedList<Pair<E,Integer>> data; //La clase Pair se da en el anexo
A. Explicar grficamente cmo sera la representacin, basada en cada una de los dos opciones, del siguiente
conjunto:
C={7,3,5,7,3,2,7,9,7}
B. Implementar las siguientes operaciones del multiconjunto. Para la OPCION1: size, add, y remove e
iterator. Para la OPCION2: size y add.
C. Indicar cul sera el coste temporal de las 6 operaciones implementadas en el apartado anterior.
D. Serviran las operaciones a nivel de conjunto (unin,) heredadas de la clase abstracta? Justificar la
respuesta para ambas opciones e indicar, si procede, los requisitos para que se pudiesen usar.
(NOTA: En el anexo se proporciona addAll como muestra)

EJERCICIO 2 (3 puntos)
Suponer que se ha implementado completamente un clase para multiconjuntos correspondiente a la opcin 1 del
apartado anterior y que la hemos llamado MultiSet<E>.
A. Explicar los pasos necesarios para implementar a partir de esta clase una nueva para multiconjuntos
ordenados: MultiOrderedSet<E> (slo explicar, no implementar).
B. Qu habra que hacer para que los mtodos de las operaciones entre conjuntos fuesen de coste lineal en
esta nueva clase.
C. Implementar el mtodo equals para MultiOrderedSet de manera que el coste sea lineal.

EJERCICIO 3 (2 puntos)
Se dispone de las siguientes representaciones grficas del rea de datos de varios tipos de diccionarios:
Opcin 1:

0
1
2
3
4
(Book,Libro) (Sky,Cielo) (House,Casa) (Door,Puerta) (Cloud,Nube)

Opcin 2:
(Book,Libro)

(Sky,Cielo)

(House,Casa)

(Door,Puerta

Opcin 3:
(House,Casa)
(Cloud,Nube)
(Book,Libro)

(Sky,Cielo)

(Door,Puerta

Dar un rea de datos en JAVA para cada una de las tres opciones anteriores.
(Nota: Para la opcin 3 no se puede usar la clase TreeSet ni la clase TreeMap)

(Cloud,Nube)

ANEXO
public interface Set<E> extends Collection<E>
{
// Basic operations
int size();
boolean isEmpty();
boolean contains(Object element);
boolean add(E element);
boolean remove(Object element);
Iterator<E> iterator();
// Bulk operations
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
boolean removeAll(Collection<?> c);
boolean retainAll(Collection<?> c);
void clear
// Array Operations
Object[] toArray();
<T> T[] toArray(T[] a);
}

public interface Map<K,V> {

V put(K key, V value);
V get(Object key);
V remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
void putAll(Map<? extends K,
? extends V> m);
void clear();
public Set<K> keySet();
public Collection<V> values();
public Set<Map.Entry<K,V>> entrySet();
public interface Entry {
K getKey();
V getValue();
V setValue(V value);
}
}

public interface List<E> extends Collection<E>

{
boolean add(E e);
void add(int index, E element);
boolean addAll(Collection<? extends E> c);
void clear();
boolean contains(Object o);
boolean equals(Object o);
E get(int index);
boolean isEmpty();
Iterator<E> iterator();
ListIterator<E> listIterator();
E remove(int index);
boolean remove(Object o);
E set(int index, E element);
int size();

public class Pair<K,V> {

private K first;
private V second;
Pair(K theFirst, V theSecond);
K getFirst();
V getSecond();
void setFirst();
void setSecond();
}
public boolean addAll(Collection<E> c)
{
boolean modified = false;
Iterator<E> e = c.iterator();
while (e.hasNext()) {
if (add(e.next()))
modified = true;
}
return modified;
}

SOLUCIONES
1.A. Rep. Grfica (0.8 puntos)
OPCION1:
OPCION2:

Los elementos van directamente en la lista

C=(7,3,5,7,3,2,7,9,7)
Lista de pares de la forma (elemento, nmero_de_veces). Se ahorra espacio
cuando hay muchas repeticiones de elementos.
C=((7,4) (3,2) (5,1) (2,1) (9,1))

1.B. Size, add,[remove e iterator]

OPCION1: (1 punto)
public int size(){ return data.size(); }
public boolean add(E e){ return data.add(e); }
public boolean remove(Object e){ return data.remove(e); }
public Iterator iterator(){ return data.iterator(); }
OPCION2: (2 puntos)
public int size(){
int cont=0
for (Pair<E,Integer> par in data){
cont+=par.getSecond();
return cont;
}
public boolean add(E e){
Iterator<Par<E,Integer>> itr=data.listIterator();
while (itr.hasNext()){
Pair<E,Integer> par=itr.next();
if ((par.getFirst()==e)){
par.setSecond(par.getSecond()+1);
return true;
}
}
return data.add(new Pair<E,Integer>(e,1));
}
1.C. Coste temporal (0.6 puntos)
COSTE
Opcin 1
Opcin 2

Size
O(1)
O(n)

add
O(1)
O(n)

remove
O(n)
-

iterator
O(1)
-

1.D. Operaciones entre conjuntos heredades ok? (0.6 puntos)

Como se basan en usar un iterador, sirven para la opcin 1 (ya que se recorren elementos) pero
no sirven para la opcin 2 a menos que se haga un iterador propio (no vale el de las listas porque se
recorren pares).

2.A. MultiOrderedSet<E>? (0.5 puntos)

Hay de heredar de la clase MultiSet<E> y sobreescribir la operacin add para insertar en orden.
2.B. Coste lineal? (0.5 puntos)
Hay que sobreescribir las operaciones entre conjuntos siguiendo el algoritmo de mezcla.
2.c. Equals (2 puntos)
public boolean equals(Object o){
if (this==o) return true;
if (!(o instanceof Set)) return false;
Set c = (Set) o;
if (c.size() != this.size()) return false;
Iterator<E> itr1=this.iterator();
Iterator<E> itr2=c.iterator();
while (itr1.hasNext() and itr2.hasNext()){
E elem1=itr1.next();
E elem2=itr2.next();
if (elem1.compareTo(elem2)!=0)
return false;
}
return true;
}
3.A. (0.5 puntos)
Opcin ms fcil de implementar
ArrayList<Entry<K,V>> data;
siendo los campos de Entry<K,V>:
K clave;
V valor;

Opcin peor que dara ms trabajo

Entry<K,V>[] data;
int elements;
siendo los campos de Entry<K,V>:
K clave;
V valor;

3.B. (0.5 puntos)

Opcin ms fcil de implementar
LinkedList<Entry<K,V>> data;
siendo los campos de Entry<K,V>:
K clave;
V valor;

2.C. (1 punto)
Entry<K,V> root;
siendo los campos de Entry<K,V>:
K clave;
V valor;
Entry left;
Entry right;

Opcin peor que dara ms trabajo

Entry<K,V> first;
siendo los campos de Entry<K,V>:
K clave;
V valor;
Entry next;
Entry previous;