Deber numero Dos de Estructuras de Datos - Paralelo 3
En este post voy a explicar como hice el deber numero dos de la clase de Estructuras de Datos del Ing. Jorge Rodriguez.
Para empezar tenemos que completar el sgte. codigo para que corra:
public static void main(String[] args){
LinkedList<Coordenada> conjunto1 = new LinkedList<>();
LinkedList<Coordenada> conjunto2 = new LinkedList<>();
LinkedList<Coordenada> union, interseccion, resta;
Programa.cargarC1(conjunto1);
Programa.cargarC2(conjunto2);
union = Conjunto.union(conjunto1,conjunto2);
interseccion = Conjunto.interseccion(conjunto1,conjunto2);
resta = Conjunto.diferencia(conjunto1,conjunto2);
Conjunto.imprimir(union);
Conjunto.imprimir(interseccion);
Conjunto.imprimir(resta);
}
private static void cargarC1(LinkedList<Coordenada> conjunto){
conjunto.add(new Coordenada(10, 10, "Ciudad 1"));
conjunto.add(new Coordenada(20, 20, "Ciudad 2"));
conjunto.add(new Coordenada(30, 30, "Ciudad 3"));
conjunto.add(new Coordenada(40, 40, "Ciudad 4"));
}
private static void cargarC2(LinkedList<Coordenada> conjunto){
conjunto.add(new Coordenada(50, 50, "Ciudad 5"));
conjunto.add(new Coordenada(20, 20, "Ciudad 2"));
conjunto.add(new Coordenada(60, 60, "Ciudad 6"));
conjunto.add(new Coordenada(40, 40, "Ciudad 4"));
}
}
Este programa representauna serie de conjuntos con unas listas enlazadas. Los contenidos de estas listas son cargados por los metodos cargarC1 y cargarC2.
Para que este programa pueda correr, necesitamos algunas cosas:
Una Clase llamada Conjunto
Cuatro metodos estaticos dentro de esa clase: union, interseccion , diferencia e imprimir.
Dos metodos estaticos en la clase Programa: cargar ( la cual lee un archivo de texto y usa la informacion dentro para crear una LinkedList) y un metodo guardar ( el cual guarda los contenidos de la LinkedList en un archivo de texto).
Primero me concentre en crear los metodos de la clase conjunto ya que son los mas importantes para el funcionamiento del programa.
El primer metodo que cree fue el metodo union:
public static LinkedList<Coordenada> union(LinkedList conjunto1, LinkedList conjunto2){
LinkedList<Coordenada> resultado = new LinkedList<>();
LinkedList<Coordenada> conjuntoGrande;
LinkedList<Coordenada> conjuntoPequeño;
if( conjunto1.size() < conjunto2.size() ){
conjuntoGrande = conjunto2;
conjuntoPequeño = conjunto1;
}
else{
conjuntoGrande = conjunto1;
conjuntoPequeño = conjunto2;
}
resultado.addAll(conjuntoGrande);
Iterator iter = conjuntoPequeño.iterator();
Coordenada tmp;
Coordenada tmp2;
while( iter.hasNext() ){
tmp = (Coordenada)iter.next();
for(int i =0; i < resultado.size(); i++){
tmp2 = (Coordenada) resultado.get(i);
if(tmp2.equals(tmp)){
break;
}
else{
resultado.addLast(tmp);
}
}
En este metodo, obtenemos dos listas enlazadas que entran por parametro. Usamos un condicional para escoger la mas lista con mas contenidos que se guarda en la variable conjuntoGrande, mientras que la mas pequeña se guarda en la variable conjuntoPequeño. Despues declaramos una variable de tipo LinkedList y le agregamos todos los contenidos de conjuntoGrande. A continuacion use un iterador para recorrer todos los contenidos del conjunto pequeño y copararlos con los contenidos del conjunto resultado. Si el contenido del conjuntoPequeño era igual (aqui se uso el metodo equal() ) a uno de los elementos de resultado, no se lo agregaba. Sin embargo esto creo el primer error del programa, ya que la forma en que lo implemente me dio la sgte. salida:
El primer grupo de Coordenadas deberia solo tener 6 elementos que correspondan a las ciudades 1, 2, 3, 4, 5 y 6. Sin embargo se puede ver que hay 21 Coordenadas. Deje el arreglo de este metodo para despues.
Me enfoque mas en el segundo metodo que es la interseccion:
public static LinkedList<Coordenada> interseccion(LinkedList conjunto1, LinkedList conjunto2){
LinkedList<Coordenada> resultado = new LinkedList<>();
Iterator iter = conjunto1.iterator();
Coordenada tmp;
Coordenada tmp2;
while( iter.hasNext() ){
tmp = (Coordenada)iter.next();
for(int i =0; i < conjunto2.size(); i++){
tmp2 = (Coordenada) conjunto2.get(i);
if(tmp2.equals(tmp)){
resultado.addLast(tmp);
break;
}
Aqui se recorre la primera lista con un iterador y se usa un lazo para comparar cada elemento de esta lista con la de la segunda. si se esncuentra un elemento de la segunda lista que es igual al elemento que se esta viendo actualmente en el iterador, se agrega ese elemento a la lista resultado y se hace un break en el lazo, lo cual noslleva al sgte. elemento del iterador. al final se retorna la lista resultado.
El tercer metodo es diferencia:
public static LinkedList<Coordenada> diferencia(LinkedList conjunto1, LinkedList conjunto2){
LinkedList<Coordenada> interseccion = interseccion(conjunto1, conjunto2);
LinkedList<Coordenada> resultado = new LinkedList<>();
resultado.addAll(conjunto1);
Iterator iter = interseccion.iterator();
tmp = (Coordenada) iter.next();
for(int i = 0; i<resultado.size(); i++){
if( tmp.equals(resultado.get(i)) ){
resultado.remove(i);
}
Aqui se crea una lista llamada interseccion a la cual se le asigna la interseccion de las dos listas que entran por parametro y una lista llamada resultado a la cual se le agrega los elementos de la orimera lista por parametro. Despues se usa un iterador en la lista interseccion y un lazo en la lista resultado con la cual se chequea igualdad de elementos. Todo elemnto que se encuentra en las dos listas se lo remueve de la lista resultado y se retorna esa lista.
Aqui regrese al primer metodo donde simplemente lo reescribi en terminos de intersecciones y diferencia. Basicamente el metodo diferencia se deshace de los elementos repetidos, y el metodo interseccion se encarga de guardar una copia de cada elemento repetido. Asi que para la union simplement cree cuatro listas (las dos primeras son para asignar las listas de parametro a listas locales):
LinkedList<Coordenada> con1 = conjunto1;
LinkedList<Coordenada> con2 = conjunto2;
LinkedList<Coordenada> resta1Menos2 = diferencia(con1, con2);
LinkedList<Coordenada> resta2Menos1 = diferencia(con2, con1);
LinkedList<Coordenada> resultado = new LinkedList<> LinkedList<Coordenada> interseccion = interseccion(conjunto1,conjunto2);
BAsicamente la union(a,b) va a tener los mismos elementos de una lista que tenga los elementos de la diferencia(a,b), diferencia(b,a) e interseccion(a,b). Asi que solo agregue los elementos de esas operaciones a la lista resultado que se la retorna al final. Esto me dio el sgte output:
Para el metodo de imprimir solo use un FOR EACH para imprimir por pantalla cada Coordenada.
Para el metodo cargar en la clase Programa simplemente reuse el mismo metodo que esta en la clase Coordenada que usamos en clase.
If it ain´t broke, don´t fix it.
En el sgte. metodo, guardar, use un FileWriter y un BufferedWriter para escoger la representacion de String de las coordenadas y escribirlas en un archivo.
private static void guardar(LinkedList<Coordenada> conjunto, String archivo){
LinkedList<Coordenada> lista = conjunto;
FileWriter fw;
BufferedWriter bw;
Iterator iter = lista.iterator();
String linea;
try{
fw = new FileWriter(archivo);
bw = new BufferedWriter(fw);
while(iter.hasNext()){
linea = iter.next().toString();
bw.write(linea);
bw.newLine();
}catch(IOException ex){
System.out.println("Error de escritura!! >:0(");
}
Use un iterador para recorrer la lista que se entrega por parametro, guerde su representacion en String en una variable llamada linea:
while(iter.hasNext()){
linea = iter.next().toString();
bw.write(linea);
bw.newLine();
Y al final se cierra el archivo con el comando bw.close();.
En el metodo main de Programa, use el metodo cargar para darle los valores a conjunto1 y conjunto2.
izzy806
baratheonpilled
2087
gummygunk
discoholicmusic
turnnoffyourmind
snowghoul
stormborns
theartofmadeline