Combinaciones sin repetición en Java (II)

Ya vimos en otro post un método recursivo para calcular las combinaciones sin repetición de una lista de elementos y ahora vamos a ver como hacerlo de forma iterativa con un iterador. La forma de usar este iterador sería así:

IteradorCombinacion it = new IteradorCombinacion(n, m);
  Iterator s = it.iterator();
  ArrayList l2 = new ArrayList();

  while (s.hasNext()) {

   List listares = (List) s.next();
    l2.add(listares);
    
  }

Siendo n la lista de elementos y m el Integer que define el tamaño de las combinaciones, todas las soluciones estarán en l2. En cuanto al rendimiento este método es unas 400% más rápido aproximadamente que el recursivo visto en el otro post.

La clase IteradorCombinacion.java lo podéis descargar aquí. ¡Espero que os sea de utilidad!

Si tienen alguna duda sobre este artículo o algún otro tema en el que pueda ser útil, no dude en mandarme un mail a: bobsfera@gmail.com o escribe un comentario!

Añade código resaltado en Blogger

Después de indignarme por no poder poner código en condiciones en el blog, me he puesto a buscar y he encontrado una forma que funciona a la perfección, utilizar syntax highlight. Este descubrimiento lo he hecho gracias al blog-indomita y allí podéis ver las instrucciones para ponerlo.

Simplemente añadir que como no tenía a mano un servidor para subir los archivos me he creado en un momento un Google Site y he subido allí los archivos.

Ejemplo:

public boolean compruebaVC(List vert) {
  boolean res = true;
  for (Edge e : edges) {
   if (!(vert.contains(e.getVertex1()) || vert.contains(e.getVertex2()))) {
    res = false;
    break;

   }
  }

  return res;

 }

Si tienen alguna duda sobre este artículo o algún otro tema en el que pueda ser útil, no dude en mandarme un mail a: bobsfera@gmail.com o escribe un comentario!

Combinaciones sin repetición en Java (I)

Para un trabajo de una asignatura he necesitado calcular las combinaciones sin repetición de un cierto tamaño de una lista. Al final he obtenido dos métodos, uno recursivo (con ayuda de Edulix) y otro iterativo (con ayuda de Daniel Cáceres) hecho con los iteradores:

RECURSIVO

public static void comb(List<String> a, List<String> b,List<List<String>> solutions, int depth) {

  if (a.size() == depth) {
           Collections.sort(a);
               if (!solutions.contains(a)) {
                 solutions.add(a);
                }

   }

for (String str : b) {
 List<String> aux = new LinkedList<String>();
 List<String> baux = new LinkedList<String>();
 baux.addAll(b);
 baux.remove(str);
 aux.addAll(a);
 aux.add(str);
 comb(aux, baux, solutions, depth);

 if (!solutions.isEmpty()) {
  break;
 }

  }
}

Siendo la lista a una lista de strings vacía, la lista de strings b la lista con los elementos a hacer las combinaciones y sol una lista de listas de strings en dónde estarán las soluciones. El int depth es el tamaño de los conjuntos de las combinaciones.

La versión iterativa la dejaremos para otro post pero os puedo ir adelantando que es casi 4 veces más rápida que esta versión =)

Si tienen alguna duda sobre este artículo o algún otro tema en el que pueda ser útil, no dude en mandarme un mail a: bobsfera@gmail.com o escribe un comentario!