Java笛卡尔积算法 Java笛卡尔积算法原理与实现方法详解

public class Test {
 private static String[] aa = { "aa1", "aa2" };
 private static String[] bb = { "bb1", "bb2", "bb3" };
 private static String[] cc = { "cc1", "cc2", "cc3", "cc4" };
 private static String[][] xyz = { aa, bb, cc };
 private static int counterIndex = xyz.length - 1;
 private static int[] counter = { 0, 0, 0 };
 public static void main(String[] args) throws Exception {
  for (int i = 0; i < aa.length * bb.length * cc.length; i++) {
   System.out.print(aa[counter[0]]);
   System.out.print("\t");
   System.out.print(bb[counter[1]]);
   System.out.print("\t");
   System.out.print(cc[counter[2]]);
   System.out.println();
   handle();
  }
 }
 public static void handle() {
  counter[counterIndex]++;
  if (counter[counterIndex] >= xyz[counterIndex].length) {
   counter[counterIndex] = 0;
   counterIndex--;
   if (counterIndex >= 0) {
    handle();
   }
   counterIndex = xyz.length - 1;
  }
 }
}

aa1 bb1 cc1
aa1 bb1 cc2
aa1 bb1 cc3
aa1 bb1 cc4
aa1 bb2 cc1
aa1 bb2 cc2
aa1 bb2 cc3
aa1 bb2 cc4
aa1 bb3 cc1
aa1 bb3 cc2
aa1 bb3 cc3
aa1 bb3 cc4
aa2 bb1 cc1
aa2 bb1 cc2
aa2 bb1 cc3
aa2 bb1 cc4
aa2 bb2 cc1
aa2 bb2 cc2
aa2 bb2 cc3
aa2 bb2 cc4
aa2 bb3 cc1
aa2 bb3 cc2
aa2 bb3 cc3
aa2 bb3 cc4

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class DescartesTest {
 /**
  * 获取N个集合的笛卡尔积
  *
  * 说明：假如传入的字符串为："1,2,3==5,6==7,8"
  *  转换成字符串数组为：[[1, 2, 3], [5, 6], [7, 8]]
  *  a=[1, 2, 3]
  *  b=[5, 6]
  *  c=[7, 8]
  *  其大小分别为：a_length=3，b_length=2，c_length=2，
  *  目标list的总大小为：totalSize=3*2*2 = 12
  *  对每个子集a，b，c，进行循环次数=总记录数/(元素个数*后续集合的笛卡尔积个数)
  *  对a中的每个元素循环次数=总记录数/(元素个数*后续集合的笛卡尔积个数)=12/(3*4)=1次，每个元素每次循环打印次数：后续集合的笛卡尔积个数=2*2个
  *  对b中的每个元素循环次数=总记录数/(元素个数*后续集合的笛卡尔积个数)=12/(2*2)=3次，每个元素每次循环打印次数：后续集合的笛卡尔积个数=2个
  *  对c中的每个元素循环次数=总记录数/(元素个数*后续集合的笛卡尔积个数)=12/(2*1)=6次，每个元素每次循环打印次数：后续集合的笛卡尔积个数=1个
  *
  *  运行结果：
  *  [[1, 2, 3], [5, 6], [7, 8]]
   1,5,7,
   1,5,8,
   1,6,7,
   1,6,8,
   2,5,7,
   2,5,8,
   2,6,7,
   2,6,8,
   3,5,7,
   3,5,8,
   3,6,7,
   3,6,8]
   从结果中可以看到：
   a中的每个元素每个元素循环1次，每次打印4个
   b中的每个元素每个元素循环3次，每次打印2个
   c中的每个元素每个元素循环6次，每次打印1个
  *
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  String str ="1,3,6,7==4,5,8,9==3,4==43,45,8,9==35,4";
  List<String> result = descartes(str);
  System.out.println(result);
 }
 @SuppressWarnings("rawtypes")
 public static List<String> descartes(String str) {
  String[] list = str.split("==");
  List<List> strs = new ArrayList<List>();
  for(int i=0;i<list.length;i++){
  strs.add(Arrays.asList(list[i].split(",")));
  }
  System.out.println(strs);
  int total = 1;
  for(int i=0;i<strs.size();i++){
   total*=strs.get(i).size();
  }
  String[] mysesult = new String[total];
  int now = 1;
  //每个元素每次循环打印个数
  int itemLoopNum = 1;
  //每个元素循环的总次数
  int loopPerItem =1;
  for(int i=0;i<strs.size();i++){
   List temp = strs.get(i);
   now = now*temp.size();
   //目标数组的索引值
   int index=0;
   int currentSize = temp.size();
   itemLoopNum = total/now;
   loopPerItem = total/(itemLoopNum*currentSize);
   int myindex = 0;
   for(int j=0;j<temp.size();j++){
    //每个元素循环的总次数
    for(int k=0;k<loopPerItem;k++){
     if(myindex==temp.size())
      myindex=0;
     //每个元素每次循环打印个数
     for(int m=0;m<itemLoopNum;m++){
      mysesult[index]=(mysesult[index]==null?"":mysesult[index]+",")+((String)temp.get(myindex));
      index++;
     }
     myindex++;
    }
   }
  }
  return Arrays.asList(mysesult);
 }
}

public static void fn(List<String[]> list,String[] arr,String str){
//迭代list
 List<String> li = new ArrayList<String>();
  for(int i=0;i<list.size();i++){
   //取得当前的数组
   if(i==list.indexOf(arr)){
    //迭代数组
    System.out.println(arr.length);
    for(String st : arr){
     st = str + st;
     if(i<list.size()-1){
      fn(list,list.get(i+1),st);
     }else if(i==list.size()-1){
      li.add(st);
     }
    }
   }
  }
  for(int i = 0 ; i < li.size();i++ )
  {
   System.out.println(li.get(i));
  }
}