Question

求java实现String list[] = { "1", "2", "3" }; 的排列组合代码

要求输出 【1，2】【 1，3】 【2，3】 【1，2，3，】里不能有重复的，组与组不能重复（1，2和2，1重复）。
要求不能有重复的出现【2，2】list的个数是未知，不能输出1位的【1】，还要输出多位的如【1，2，3】如果list是1234，那就输出【1，2】【1，3】【1，4】【2，3】【2，4】【3，4】【1，2，3】【1，2，4】【1，3，4】【2，3，4】【1，2，3，4】，list里的是字符串，不是数，可以是String list[] = { "test", "aaa", "yyy",..... }; 可能2个，也可能100个，要求输出从少到多，先输出2个的组合，再3个4个等。

Answer 1

楼上的代码好复杂...其实几个循环就可以了,用不着那么多if判断

import java.util.ArrayList;

public final class SpecialStringSorter {
public static String[] sort(String[] list){
ArrayList<String> outbuilder=new ArrayList<String>();
if(list.length<2) throw new RuntimeException();//如果list长度小于2会抛出运行时异常(你想换掉就换掉,比如说返回本身)
for(int a=2;a<=list.length;a++){ //这一层循环是迭代输出括号里的元素数(a代表输出中的[]里的元素数),不断增加
for(int b=0;b<=list.length-a;b++){ //这一层循环是迭代输出括号里的开头数
for(int c=b+1;c<=list.length-a+1;c++){//这一层循环是第二个数
StringBuilder sb=new StringBuilder("[");
sb.append(list[b]);
sb.append(","+list[c]);
for(int d=1;d<a-1;d++){ //这一层循环是一个[]内容的生成循环
sb.append(","+list[c+d]);
}
sb.append("]");
outbuilder.add(sb.toString());
}
}
}
String[] result=new String[outbuilder.size()];
int i=0;
for(Object resultBuilder:outbuilder){
result[i]=(String)resultBuilder;
i++;
}
return result;
}
public static void main(String[] args){
String[] test={
"1","2","3","4"
};
String[] sortResult=sort(test);
for(String out:sortResult){
System.out.print(out);
}
}
}

Answer 2

对于这个问题，我首先需要纠正一下楼主的措辞，这是个组合问题，跟排列无关，用排列组合亦不恰当。下面说下我的想法
元素不能重复，首先应该去掉相同的元素，最好的办法是用set来实现。参考api
Arrays.asList set.addAll
其实呢，这个是一个递归的过程，考虑下面情况
对于数组 {“1”}，它的组合数就是{“1”}。
如果再加上一个元素“2“到上面的数组中，那么，如果这个”2“不用，实质上跟{"1"}的情况是一样的，这与不能重复相矛盾，所以”2“一定要用，就是在"1"中再加上”2“；于是我们得到
对于数组{”1“，”2“}它的组合数是{”1“} 再加入一个{”2“}。也许你也考虑到另外一种情况，即”2“也是它的一个组合数，我们考虑丢了，为什么呢，因为在{”1“}中实质上还有一个称为空的集合。这样的话，重新整理一下：
1.对于list = {"1"},它的组合包括 {"1"},以及 empty.
2.对于list={"1","2"},它的组合包括{”1“，”2“}（在{”1“}中加了”2“），{”2“}（在empty中加入”2“），也许你还会讲还应该包括{”1“}，但是这个{”1“}我们已经在第1步就已经算出来了，不用再考虑了。
按照这样的规则进行下去，你会发现这样就把所有的组合数遍历出来了。要具体的代码就等会儿，我现在有事。

Answer 3

代码如下：
调用时为：
combination(list, 1, list.length, ",", false, false);
/**
* 把字符串数组按排列组合来组成新的字符串数组
* @param src 字符串数组
* @param min 从那个数组位置开始组合排列
* @param max 到那个数组位置结束
* @param mark 字符分割符
* @param isPermutation 是否是排列
* @return 按排列组合来组成新的字符串数组
*/
public static String[] combination(String[] src, int min, int max, String mark, boolean isPermutation, boolean includeSelf) {
List list = new ArrayList();
if (min > max) {
int t = max;
max = min;
min = t;
}
if (min < 1)
min = 1;
if (max < 1 || max > src.length)
max = src.length;
for (int i = min; i <= max; i++) {
combinationRecursive(list, src, new StringBuffer(""), i, 0, mark, isPermutation, includeSelf);
}
return (String[]) list.toArray(new String[0]);
}

private static void combinationRecursive(List list, String[] src, StringBuffer str, int length, int start, String mark, boolean isPermutation, boolean includeSelf) {
if (length < 1 || start > src.length || length > src.length)
return;
if (length == 1) {
if (str.length() == 0 && !includeSelf)
return;
for (int i = isPermutation ? 0 : start; i < src.length; i++) {
StringBuffer result = new StringBuffer(str);
result.append(src[i]);
list.add(result.toString().trim());
}
} else {
for (int i = isPermutation ? 0 : start; i < src.length; i++) {
StringBuffer temp = new StringBuffer(str);
combinationRecursive(list, src, temp.append(src[i] + mark), length - 1, i + 1, mark, isPermutation, includeSelf);
}
}
}

Answer 4

public class abc {
public static void main(String[] args) {
String list[] = { "1", "2", "3" ,"4"};
for (int i = 0; i < list.length; i++) {
System.out.println(list[i]);
}
for (int i = 0; i < list.length; i++) {
for (int j = i; j < list.length ; j++) {
System.out.println(list[i]+","+list[j]);
}
}
}
}
给分，再来点，分太少了

Answer 5

楼上的根本就不对，也不检查下就来拿分，
楼主问个事，你这个如果要是在程序中出现了1 2 3 2 这样4个数字的话，那么你想怎么处理？