Foro de elhacker.net

Programación => Java => Mensaje iniciado por: Beginner Web en 13 Abril 2019, 21:02 pm


Título: bubblesort arraylist
Publicado por: Beginner Web en 13 Abril 2019, 21:02 pm
Hola como puedo hacer para ordenar un arraylist de objetos por nombre? Intente el metodo de la burbuja pero no pasa nada  :huh:

Código
  1. public void ordenar() {
  2.         Persona cambio;
  3.         boolean ordenado = true;
  4.         while (ordenado == true) {
  5.             ordenado = false;
  6.             for (int i = 0; i < personas.size() - 1; i++) {
  7.                 if (personas.get(i).getNombre().compareTo(personas.get(i + 1).getNombre()) > 0) {
  8.                     cambio = personas.get(i);
  9.                     personas.set(i, personas.get(i + 1));
  10.                     personas.set(i + 1, cambio);
  11.                     ordenado = true;
  12.                 }
  13.             }
  14.         }
  15.     }

Título: Re: bubblesort arraylist
Publicado por: Serapis en 13 Abril 2019, 23:19 pm
Los algoritmos de ordenamiento, suelen tener al menos dos bucles (uno dentro de otro).
Tu solo has puesto un bucle, luego al término del mismo, tan solo habrías obtenido el menor/mayor de todos ellos y por tanto solo habrías colocado la 1ª pieza. falta hacer lo mismo para los x-1 piezas restantes...

Sean 20 elementos a ordenar... (0 a 19)
Código:
bucle para j desde 0 hasta 20-2  <----- ojo, 2 ítems menos, solo debe llegar al 18, para que la última comparaci´´on sea el 18 con el 19, resulta redundante comparar cada vez el 19 con el 19.
   temp = item(j)
   // j + 1, por que es redundante comparar 5 con 5, 8 con 8, 320 con 320. 
   // Igualmente como a la salida del bucle iterno cada vez 'j' ya está ordenado, es redundante reiniciar el bucle interno desde 0.
   bucle para k desde j+1 hasta 20-1  <--- este debe llegar hasta 19.
       si (item(k) > temp) entonces
          intercambiar item(k) con temp
       fin si
   siguiente
   item(j) = temp
siguiente

Título: Re: bubblesort arraylist
Publicado por: Beginner Web en 13 Abril 2019, 23:48 pm
Perdon?

Título: Re: bubblesort arraylist
Publicado por: rub'n en 14 Abril 2019, 04:27 am
Cita de: Beginner Web en 13 Abril 2019, 21:02 pm
Hola como puedo hacer para ordenar un arraylist de objetos por nombre? Intente el metodo de la burbuja pero no pasa nada  :huh:

Código
  1. public void ordenar() {
  2.         Persona cambio;
  3.         boolean ordenado = true;
  4.         while (ordenado == true) {
  5.             ordenado = false;
  6.             for (int i = 0; i < personas.size() - 1; i++) {
  7.                 if (personas.get(i).getNombre().compareTo(personas.get(i + 1).getNombre()) > 0) {
  8.                     cambio = personas.get(i);
  9.                     personas.set(i, personas.get(i + 1));
  10.                     personas.set(i + 1, cambio);
  11.                     ordenado = true;
  12.                 }
  13.             }
  14.         }
  15.     }

Tu algoritmo funciona, ordena de manera ascendente que estarás haciendo cuando lo invocas?

hagamosle caso a NEBIRE

Bean Persona

Código
  1. import java.util.Objects;
  2.  
  3. public class Persona {
  4.  
  5.     private String nombre;
  6.     private int edad;
  7.     private String apellido;
  8.     private boolean esAlto;
  9.     private double peso;
  10.  
  11.     public String getNombre() {
  12.         return nombre;
  13.     }
  14.  
  15.     public void setNombre(String nombre) {
  16.         this.nombre = nombre;
  17.     }
  18.  
  19.     public int getEdad() {
  20.         return edad;
  21.     }
  22.  
  23.     public void setEdad(int edad) {
  24.         this.edad = edad;
  25.     }
  26.  
  27.     public String getApellido() {
  28.         return apellido;
  29.     }
  30.  
  31.     public void setApellido(String apellido) {
  32.         this.apellido = apellido;
  33.     }
  34.  
  35.     public boolean isEsAlto() {
  36.         return esAlto;
  37.     }
  38.  
  39.     public void setEsAlto(boolean esAlto) {
  40.         this.esAlto = esAlto;
  41.     }
  42.  
  43.     public double getPeso() {
  44.         return peso;
  45.     }
  46.  
  47.     public void setPeso(double peso) {
  48.         this.peso = peso;
  49.     }
  50.  
  51.     @Override
  52.     public boolean equals(Object o) {
  53.         if (this == o) return true;
  54.         if (!(o instanceof Persona)) return false;
  55.         Persona persona = (Persona) o;
  56.         return edad == persona.edad &&
  57.                 esAlto == persona.esAlto &&
  58.                 Double.compare(persona.peso, peso) == 0 &&
  59.                 Objects.equals(nombre, persona.nombre) &&
  60.                 Objects.equals(apellido, persona.apellido);
  61.     }
  62.  
  63.     @Override
  64.     public int hashCode() {
  65.         return Objects.hash(nombre, edad, apellido, esAlto, peso);
  66.     }
  67.  
  68.     @Override
  69.     public String toString() {
  70.         final StringBuilder sb = new StringBuilder("\nPersona");
  71.         sb.append("\nnombre='").append(nombre).append("\n");
  72.         sb.append(", edad=").append(edad);
  73.         sb.append(", apellido='").append(apellido).append("\n");
  74.         sb.append(", esAlto=").append(esAlto);
  75.         sb.append(", peso=").append(peso);
  76.         sb.append("]");
  77.         return sb.toString();
  78.     }
  79. }
  80.  

Código
  1. import java.util.*;
  2.  
  3. /**
  4.  * @rubn ,@NEBIRE, @Ana XD 
  5.  */
  6. public class OrdenarPersonaPorNombre {
  7.  
  8.     private List<Persona> personaList = new ArrayList<>();
  9.     private static final String TITLE = "Personas Ordenadas Alfabeticamente...";
  10.  
  11.    OrdenarPersonaPorNombre () {
  12.         fillList();
  13.         ordenar();
  14.     }
  15.  
  16.     private void fillList() {
  17.         final Persona persona = new Persona();
  18.         persona.setNombre("Raul");
  19.         persona.setEdad(30);
  20.         persona.setApellido("Gonzales");
  21.         persona.setPeso(56);
  22.         persona.setEsAlto(Boolean.TRUE);
  23.  
  24.         final Persona persona2 = new Persona();
  25.         persona2.setNombre("Josefina");
  26.         persona2.setEdad(40);
  27.         persona2.setApellido("Sinforoza");
  28.         persona2.setPeso(60);
  29.         persona2.setEsAlto(Boolean.FALSE);
  30.  
  31.         final Persona persona3 = new Persona();
  32.         persona3.setNombre("Ana");
  33.         persona3.setEdad(14);
  34.         persona3.setApellido("Begginer  Web");
  35.         persona3.setPeso(45);
  36.         persona3.setEsAlto(Boolean.FALSE);
  37.  
  38.         final Persona persona4 = new Persona();
  39.         persona4.setNombre("Babel");
  40.         persona4.setEdad(23);
  41.         persona4.setApellido("Bhahal");
  42.         persona4.setPeso(55);
  43.         persona4.setEsAlto(Boolean.TRUE);
  44.  
  45.         final Persona persona5 = new Persona();
  46.         persona5.setNombre("Mega");
  47.         persona5.setEdad(100);
  48.         persona5.setApellido("Man");
  49.         persona5.setPeso(200);
  50.         persona5.setEsAlto(Boolean.TRUE);
  51.  
  52.         personaList.add(persona);
  53.         personaList.add(persona2);
  54.         personaList.add(persona3);
  55.         personaList.add(persona4);
  56.         personaList.add(persona5);
  57.     }
  58.  
  59.     //con java 7
  60.     private void ordenar() {
  61.        /* for(int f=0; f<personaList.size();f++) {
  62.             for(int c=0; c<(personaList.size() - 1) - f; c++) {
  63.                 //personaList.size() -1, para evitar IndexOutBoundException
  64.                 //que es una exception que se produce en tiempo de ejecucion por index fuera de rango
  65.                     if(personaList.get(c).getNombre().compareTo( personaList.get(c+1).getNombre()) > 0) {
  66.                         final String auxiliar = personaList.get(c).getNombre();
  67.                         personaList.get(c).setNombre(personaList.get(c+1).getNombre());
  68.                         personaList.get(c+1).setNombre(auxiliar);
  69.                     }
  70.             }
  71.         }*/
  72.  
  73.        Collections.sort(personaList);
  74.  
  75.        System.out.println(TITLE);
  76.        for (int f=0; f<personaList.size(); f++) {
  77.            System.out.println(personaList.get(f));
  78.        }
  79.  
  80.     }
  81.  
  82.     //con java.util.Stream
  83.     private void ordenarConStreams() {
  84.  
  85.         System.out.println(TITLE);
  86.         personaList.stream()
  87.                 .sorted(Comparator.comparing(Persona::getNombre))
  88.                 .forEach(System.out::println);
  89.  
  90.     }
  91.  
  92.     public static void main(String ...blablabla) {
  93.         new OrdenarPersonaPorNombre ();
  94.     }
  95. }
  96.  

Output_
Código
  1. Personas Ordenadas Alfabeticamente...
  2.  
  3. Persona
  4. nombre='Ana
  5. , edad=14, apellido='Begginer  Web
  6. , esAlto=false, peso=45.0]
  7.  
  8. Persona
  9. nombre='Babel
  10. , edad=23, apellido='Bhahal
  11. , esAlto=true, peso=55.0]
  12.  
  13. Persona
  14. nombre='Josefina
  15. , edad=40, apellido='Sinforoza
  16. , esAlto=false, peso=60.0]
  17.  
  18. Persona
  19. nombre='Raul
  20. , edad=30, apellido='Gonzales
  21. , esAlto=true, peso=56.0]
  22.  
  23. Process finished with exit code 0
  24.  

Te he añadido en la linea 73 como hacer también con la clase Collections y su método sort

pero debemos implementar la interface Comparable<T>

cambiando a Persona



Código
  1.  
  2. public class Persona implements Comparable<Persona> {
  3.  
  4.  

implementando al método

Código
  1. public int compareTo(T o);

Código
  1.  
  2. @Override
  3. public int compareTo(Persona o) {
  4.     final Persona p1 = o;
  5.     return this.getNombre().compareTo(p1.getNombre());
  6. }

Quedando
Código
  1. import java.util.Objects;
  2.  
  3. public class Persona implements Comparable<Persona> {
  4.  
  5.     private String nombre;
  6.     private int edad;
  7.     private String apellido;
  8.     private boolean esAlto;
  9.     private double peso;
  10.  
  11.     public String getNombre() {
  12.         return nombre;
  13.     }
  14.  
  15.     public void setNombre(String nombre) {
  16.         this.nombre = nombre;
  17.     }
  18.  
  19.     public int getEdad() {
  20.         return edad;
  21.     }
  22.  
  23.     public void setEdad(int edad) {
  24.         this.edad = edad;
  25.     }
  26.  
  27.     public String getApellido() {
  28.         return apellido;
  29.     }
  30.  
  31.     public void setApellido(String apellido) {
  32.         this.apellido = apellido;
  33.     }
  34.  
  35.     public boolean isEsAlto() {
  36.         return esAlto;
  37.     }
  38.  
  39.     public void setEsAlto(boolean esAlto) {
  40.         this.esAlto = esAlto;
  41.     }
  42.  
  43.     public double getPeso() {
  44.         return peso;
  45.     }
  46.  
  47.     public void setPeso(double peso) {
  48.         this.peso = peso;
  49.     }
  50.  
  51.  
  52.     @Override
  53.     public boolean equals(Object o) {
  54.         if (this == o) return true;
  55.         if (!(o instanceof Persona)) return false;
  56.         Persona persona = (Persona) o;
  57.         return edad == persona.edad &&
  58.                 esAlto == persona.esAlto &&
  59.                 Double.compare(persona.peso, peso) == 0 &&
  60.                 Objects.equals(nombre, persona.nombre) &&
  61.                 Objects.equals(apellido, persona.apellido);
  62.     }
  63.  
  64.     @Override
  65.     public int hashCode() {
  66.         return Objects.hash(nombre, edad, apellido, esAlto, peso);
  67.     }
  68.  
  69.     @Override
  70.     public String toString() {
  71.         final StringBuilder sb = new StringBuilder("\nPersona");
  72.         sb.append("\nnombre='").append(nombre).append("\n");
  73.         sb.append(", edad=").append(edad);
  74.         sb.append(", apellido='").append(apellido).append("\n");
  75.         sb.append(", esAlto=").append(esAlto);
  76.         sb.append(", peso=").append(peso);
  77.         sb.append("]");
  78.         return sb.toString();
  79.     }
  80.  
  81.     @Override
  82.     public int compareTo(Persona o) {
  83.         final Persona p1 = o;
  84.         return this.getNombre().compareTo(p1.getNombre());
  85.     }
  86. }
  87.  

Sino implementas a Comparable, no podrías usar la linea 73 en el bean OrdenarPersonaPorNombre

Título: Re: bubblesort arraylist
Publicado por: Beginner Web en 14 Abril 2019, 07:25 am
Estoy muy confundida con tu codigo, tendre que leer mas  :o

Título: Re: bubblesort arraylist
Publicado por: rub'n en 14 Abril 2019, 07:28 am
Cita de: Beginner Web en 14 Abril 2019, 07:25 am
Estoy muy confundida con tu codigo, tendre que leer mas  :o

Pero en que? se siempre mas explicita, te comente un codigo que esta en el método ordenar.

por eso ahora veo que no es bueno editartelo mucho, pero recuerda que afuera, te econtraras tannntas maneras de hacer lo mismo, bueno eso si, unas mejores que otras XD

Título: Re: bubblesort arraylist
Publicado por: Serapis en 14 Abril 2019, 14:52 pm
Pongámoslo fácil, si al menos logras entenderlo, ya vale.

Tu tienes esto...
Código
  1. public void ordenar() {
  2.     Persona cambio;
  3.     boolean ordenado = true;
  4.     while (ordenado == true) {
  5.         ordenado = false;
  6.         for (int i = 0; i < personas.size() - 1; i++) {
  7.             if (personas.get(i).getNombre().compareTo(personas.get(i + 1).getNombre()) > 0) {
  8.                 cambio = personas.get(i);
  9.                 personas.set(i, personas.get(i + 1));
  10.                 personas.set(i + 1, cambio);
  11.                 ordenado = true;
  12.             }
  13.         }
  14.     }
  15. }


Modificando el mismo código... remplazo el bucle while por un for... y poco más...
Si simplemente quieres tirar de BubbleSort:
Código
  1. public void ordenar() {
  2.     Persona cambio;         
  3.  
  4.     for (int j = 0; j < personas.size-2; j++){
  5.         for (int i = 1; i < personas.size() - 1; i++){
  6.             if (personas.get(i).getNombre().compareTo(personas.get(j).getNombre()) > 0){
  7.                 cambio = personas.get(j);
  8.                 personas.set(j, personas.get(i));   
  9.                 personas.set(i, cambio);                                                           
  10.             }
  11.         }               
  12.     }
  13. }
  14.  


Este es el algoritmo Selectionsort, muy similar al BubbleSort, pero algo más rápido...
en cada ciclo interno, obtenemos siempre el mayor (si la comparación y el ordenamiento es de mayor a menor)  entre los que restan por ordenar... y se asigna al final de dicho bucle.
Es decir en el bucle interno se trata de encontrar el mayor

Código
  1. public void ordenar() {
  2.     Persona cambio;
  3.     Persona temp;
  4.  
  5.     for (int j = 0; j < personas.size-2; j++){
  6.         temp = personas.get(j);
  7.         for (int i = (j+1); i < personas.size() - 1; i++){
  8.             if (personas.get(i).getNombre().compareTo(temp.getNombre()) > 0){
  9.                 cambio = personas.get(i);
  10.                 personas.set(i, temp);
  11.                 temp = cambio;                                            
  12.             }
  13.         }
  14.         personas.set(j, temp);
  15.     }
  16. }
  17.  

Por qué usar Selectionsort, en vez de Bubblesort? por 2 razones, el algoritmo es casi idéntico, ambos puedes escribirlos una y otra vez de cabeza en medio minuto... y porque bubbleSort, exige: n*n comparaciones (20x20)= 400 comparaciones, en tanto que Selectionsort exige algo menos de la la mitad: ((n-1 * n)\2) = (19*20)\2 = 190, dejo a tu investigación, porque Selectionsort, exije menos.

Se puede decir que bubblesort, es 'más tonto' que Selectionsort, su memoria es de pez, no 'recuerda' nada... Selectionsort, 'recuerda' al menos el menor/mayor que se va encontrando... tampoco es mucho más inteligente, exige solo 2 líneas más y cambiar el punto de inicio del bucle interno, a cambio es el doble de rápido (hace el trabajo con la mitad de comparaciones y de tiempo).

Se puede optimizar, evitando todos esos intercambios, a cambio necesitamos recordar el índice del ítem que se localiza como menor, para al final hacer un único intercambio, es decir la cantidad de intercambios se limita como mucho al número de ciclos del bucle externo. La optimización es inapreciable para cosas como 20-1000 elementos, cuando la cosa sube en magnitudes, 1, 10, 100 milllones es cuando se aprecia...

Código
  1. public void ordenar() {
  2.     Persona temp;
  3.     int k;
  4.  
  5.     for (int j = 0; j < personas.size-2; j++){
  6.         k = j;                         
  7.         for (int i = (j+1); i < personas.size() - 1; i++){
  8.             if (personas.get(i).getNombre().compareTo(personas.get(k).getNombre()) > 0){
  9.                 k = i;
  10.             }
  11.         }
  12.         temp = personas.get(k);  
  13.         personas.set(k, personas.get(j));
  14.         personas.set(j, temp);
  15.    }
  16. }
  17.  

Modificado, para eliminar la indentación innecesaria (resultante del copy/paste/modifica)...

Título: Re: bubblesort arraylist
Publicado por: CalgaryCorpus en 14 Abril 2019, 15:13 pm
Opcion a lo mencionado previamente: Usar lambdas para implementar el comparator

Código
  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.Collections;
  4. import java.util.Comparator;
  5.  
  6. public class Persona {
  7.      String nombre;
  8.      int edad;
  9.  
  10.      public Persona(String nombre, int edad) {
  11.          this.nombre = nombre;
  12.          this.edad = edad;
  13.      }
  14.  
  15.      public static void ordenaLista(List<Persona> l, String titulo, 
  16.                                     Comparator<Persona> comp) {
  17.          Collections.sort(l, comp);
  18.          System.out.println(titulo);
  19.          for(Persona p: l) {
  20.              System.out.println(p.nombre + " " + p.edad);
  21.          }
  22.      }
  23.  
  24.      public static void main(String []args){
  25.          ArrayList<Persona> l = new ArrayList<>();
  26.          l.add(new Persona("A", 30));
  27.          l.add(new Persona("B", 29));
  28.          l.add(new Persona("C", 28));
  29.          l.add(new Persona("D", 27));
  30.  
  31.          ordenaLista(l, "Por nombre", (p1, p2) -> p1.nombre.compareTo(p2.nombre));
  32.          ordenaLista(l, "Por edad", (p1, p2) -> (p1.edad - p2.edad));
  33.      }
  34. }
  35.  



Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines