求解输出一个字符串的所有组合的问题？

Question

字符串分解
输入：输入一个任意的字符串(如：abc)
输出：所有不同的字串（如：a,ab,ac,abc,b,bc）
输出的结果是从左向右结合的，不能出现倒序，即在输入串中是前面的字符，在输出串中也是在前面，如：ba是错的。请各位出个思路或代码参考一下。谢谢

Answer 1

用双重for循环，再用一下substring（）函数就可以了

Answer 2

双for + substring()行吗？ac怎么取？

Answer 3

TO:wanchao2001(如果可以重来，我还是选择程序员)
但是隔字母的无法输出啊，应该怎么处理
如abcde的话
用双循环＋subString的话，ac ad ，ade这些怎么输出啊？没法实现啊

Answer 4

我只知道个数是2^n-1个.
思路是fun(n)=2fun(n-1)+1,这是算个数的方法,你应该可以按这个思路来做吧.
比如ab是{a,b,ab}
那么abc就是{a,b,ab  ac,bc,abc  c}.自己想吧,我没时间写代码!
用递归做!

Answer 5

public static void main(String[] args){
  char[] a= "hykwolf".toCharArray();
  int an = a.length;
  for(int i=0;i<an;i++){
    for(int j=i+1;j<an;j++){
      System.out.println(String.valueOf(a[i])+String.valueOf(a[j]));
    }
  }
}

Answer 6

搞错了，还以为你只要2位的组合呢。全部的更简单
public static void main(String[] args){
String tmp = "hykwolf";
for(int i=0;i<tmp.length();i++){
for(int j=i+1;j<tmp.length();j++){
System.out.println(tmp.substring(i,j));
}
}
}

Answer 7

论坛上以前有个类似的帖子，要求获得所有的排列组合，可参考一下
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
public class TestArrangement {
private int size; private boolean visited[]; private int array[]; private int tempArray[]; private int count; public TestArrangement() {
if (size <= 0)
size = 6;
visited = new boolean[size];
for (int i = 0; i < size; i++) {
visited[i] = false;
}
} private void DFS(int k) {
// （1）访问第K个元素，并且记录到tempArray中
visited[k] = true;
this.tempArray[count] = array[k];
count++;
if (count == size) {// 已经到头了,可以返回了
this.printAllElements();
return;
}
for (int j = 0; j < size; j++) {
if (!visited[j] && j != k) {
// （2）如果没有访问到，则递归访问
DFS(j); // （3）到这里表明第j个元素已经访问了，现在开始回退
// 标记没有被访问，
visited[j] = false;
count--;
}
}
} public void OutputArrangement() {
for (int i = 0; i < size; i++) {
reset();
DFS(i);
}
} public static void main(String args[]) {
TestArrangement t = new TestArrangement();
int array[] = new int[] { 1, 2, 3, 4, 5, 6 };
t.setArray(array);
t.setSize(array.length);
t.OutputArrangement();
} private void printAllElements() {
for (int i = 0; i < size; i++) {
System.out.print(tempArray[i]);
System.out.print(" ");
}
System.out.println("\n");
} public void setSize(int size) {
this.size = size;
} public int getSize() {
return size;
} public int[] getArray() {
return array;
} private void reset() {
for (int i = 0; i < size; i++) {
this.visited[i] = false;
this.tempArray[i] = 0;
}
count = 0;
} public void setArray(int[] array) {
this.array = array;
tempArray = new int[array.length];
}
}

Answer 8

不难啊，用个递归就可以了class CombineTest {
public static void main(String[] args) {
CombineTest ct = new CombineTest();
String s = "abcd";
String[] r = ct.Combine(s);
for (int i=0; i<r.length; i++) {
System.out.print(r[i]);
if (i != r.length-1) {
System.out.print(",");
}
}
}

         //递归
public String[] Combine(String s) {
String[] result;
if (s.length() == 1) {
result = new String[1];
result[0] = s;
} else {
String[] sub = Combine(s.substring(1));
int len = sub.length;
result = new String[2*len+1];
result[0] = s.substring(0, 1);
for (int i=0; i<len; i++) {
result[i+1] = result[0] + sub[i];
result[i+len+1] = sub[i];
}
}

return result;
}
}

Answer 9

稍微修改一下，没注意楼主的要求，还需要按组合长度顺序排列
class CombineTest {
public static void main(String[] args) {
CombineTest ct = new CombineTest();
String s = "abcd";
String[] r = ct.Combine(s);
for (int i=0; i<r.length; i++) {
System.out.print(r[i]);
if (i != r.length-1) {
System.out.print(",");
}
}
}

public String[] Combine(String s) {
String[] result;
if (s.length() == 1) {
result = new String[1];
result[0] = s;
} else {
String[] sub = Combine(s.substring(1));
int len = sub.length;
result = new String[2*len+1];
result[0] = s.substring(0, 1);
for (int i=0; i<len; i++) {
result[i+1] = result[0] + sub[i];
result[i+len+1] = sub[i];
}

                            //在这里稍微排列以下就可以了
for (int i=0; i<sub.length; i++) {
for (int j=0; j<sub.length-i; j++) {
if (result[j].length() > result[j+1].length()) {
s = result[j];
result[j] = result[j+1];
result[j+1] = s;
}
}
}
}

return result;
}
}

Answer 10

比如abc,你可以再创建一个和abc长度相同的int数组,然后将0转化为2进制数(每次加1,也就是说第2次调用这个数组时就将1转为2进制)一直到2^n-1,放进这个数组,然后每次每次取字符的时候都调用这个数组,看那几位为1,将为1的位打出来.