递归C语言排列组合方式,递归解决一种排列组合的方法

问题场景：

比如说一件商品有3中属性，每个属性又有3种不同的值，那么此时问，这几种属性可能的组合性，相信你很快就得到结果为"333=27"种，此时你可以实现的方式可以为三个for循环嵌套来实现，那么如果场景变了，如果是4种属性，那你可能就要4个for循环，那么如果此时又变成10个，那是不是要用10个循环了，此时的代码就显得笨重并且不易读，所以此时我们就可以用递归实现此业务场景。**

解决思路：

1、可以将相同属性的值放到一个List中，规定一个List的子类，如ArrayList，将所有的相同属性值都放到一个ArrayList中去，此时有多少个属性就可以得到多少个封装了相同属性值的ArrayList。

2、将上述生成的所有的ArrayList都放到个List中，即List>;

3、然后将上述List中的ArrayList顺序两个组合成一个新的LinkedList，此处新List子类型是为了和之前的ArrayList区分开来，以便后续区分对待。详见代码

代码示例：

public class MainTest {

private static List returnList = new ArrayList();

public static void main(String[] args) {

List> stateLists = new ArrayList>();

ArrayList als1 = new ArrayList<>();

als1.add("Color_1");

als1.add("Color_2");

ArrayList als2 = new ArrayList<>();

als2.add("Style_1");

als2.add("Style_2");

ArrayList als3 = new ArrayList<>();

als3.add("Size_1");

als3.add("Size_2");

ArrayList als4 = new ArrayList<>();

als4.add("High_1");

als4.add("High_2");

stateLists.add(als1);

stateLists.add(als2);

stateLists.add(als3);

stateLists.add(als4);

addstatement(stateLists);

System.out.println("returnList:"+returnList.size()+" "+returnList);

}

public static void addstatement(List> dataLists){

int len=dataLists.size();

//判断List中的size是否小于2，如果小于说明已经递归完成了

if (len<2){

returnList=dataLists;

return;

}

//第一个是 ArrayList 或 LinkedList()

int len0 ;

if(dataLists.get(0) instanceof ArrayList>){

len0 = ((ArrayList)dataLists.get(0)).size();

} else {

len0 = ((LinkedList)dataLists.get(0)).size();

}

int len1 ;

//第二个一定是 ArrayList

ArrayList secondList = (ArrayList)dataLists.get(1);

len1 = ((ArrayList)dataLists.get(1)).size();

//定义临时存放排列数据的集合默认的是ArrayList,新组合的是 LinkedList

LinkedList> tempdataLists=new LinkedList<>();

//第一层for就是循环dataLists第一个元素的

for (int i=0;i

//第二层for就是循环dataLists第二个元素的

for (int j=0;j

//判断第一个元素如果是ArrayList说明循环才刚开始

if (dataLists.get(0) instanceof ArrayList>){

ArrayList arr0= (ArrayList) dataLists.get(0);

// 创建LinkedList类型与ArrayList区分开来，用于将新的数据重新存储

LinkedList arr=new LinkedList<>();

arr.add(arr0.get(i));

arr.add(secondList.get(j));

//把排列数据加到临时的集合中

tempdataLists.add(arr);

} else {

//到这里就明循环了最少一轮,即数据中只剩下两个，一个是LinkedList，一个是ArrayList

LinkedList> arrtemp= (LinkedList>) dataLists.get(0);

LinkedList arr=new LinkedList<>();

// 取出老的LinkedList数据赋值给新的LinkedList，同时把第二个ArrayList中的数据赋值给新的LinkedList

for (int k=0;k

arr.add(arrtemp.get(i).get(k));

}

arr.add(secondList.get(j));

tempdataLists.add(arr);

}

}

}

//这是根据上面排列的结果重新生成的一个集合

List newdataLists=new ArrayList<>();

//把还没排列的数组装进来，看清楚i=2的喔，因为前面两个数组已经完事了，不需要再加进来了

for (int i=2;i

newdataLists.add(dataLists.get(i));

}

//记得把我们辛苦排列的数据加到新集合的第一位喔，不然白忙了

newdataLists.add(0,tempdataLists);

//你没看错，我们这整个算法用到的就是递归的思想。

addstatement(newdataLists);

}

}

运行结果：

returnList:1 [[[Color_1, Style_1, Size_1, High_1], [Color_1, Style_1, Size_1, High_2], [Color_1, Style_1, Size_2, High_1], [Color_1, Style_1, Size_2, High_2], [Color_1, Style_2, Size_1, High_1], [Color_1, Style_2, Size_1, High_2], [Color_1, Style_2, Size_2, High_1], [Color_1, Style_2, Size_2, High_2], [Color_2, Style_1, Size_1, High_1], [Color_2, Style_1, Size_1, High_2], [Color_2, Style_1, Size_2, High_1], [Color_2, Style_1, Size_2, High_2], [Color_2, Style_2, Size_1, High_1], [Color_2, Style_2, Size_1, High_2], [Color_2, Style_2, Size_2, High_1], [Color_2, Style_2, Size_2, High_2]]]