前几天下载了基础测试题，10道题有一道不会做，求大神们给思路，题目如下

编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如：

原始字符串是"abc"，打印得到下列所有组合情况：
"a" "b" "c"
"ab" "bc" "ca" "ba" "cb" "ac"
"abc" "acb" "bac" "bca" "cab" "cba"



虽然百度有答案，但是没有注释，也没有解释，学习要的不是答案，而是思路，只有思路会了，才能学到东西，希望会的大神能指点一下
说下大概的思路

毕老爷有讲过这题，看视频去吧

我想到办法了，可以用FOR嵌套

菜鸟一号 发表于 2015-1-6 10:45
毕老爷有讲过这题，看视频去吧

现在还在看视频，还没看到那里吧，在第几天的视频里面啊？

字符串切割，循环，递归

liqudely 发表于 2015-1-6 10:51
我想到办法了，可以用FOR嵌套

能大概讲一下思路吗？

qq8921310 发表于 2015-1-6 11:07
字符串切割，循环，递归

大哥，你这思路也太大概了:L

※无价※之宝 发表于 2015-1-6 11:11
能大概讲一下思路吗？

先把字符串转换成字符数组，然后用2重for循环打印出所有组合

你可以用递归，获取长度，比如第一次是3，进行一次全排列，然后调用自身，长度改为2，全排列，依次类推

1. package com.itheima;
   
2. 
   
3. import java.util.Scanner;
   
4. 
   
5. /*
   
6. * 编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如：
   
7. 
   
8.         原始字符串是"abc"，打印得到下列所有组合情况：
   
9.         "a" "b" "c"
   
10.         "ab" "bc" "ca" "ba" "cb" "ac"
    
11.         "abc" "acb" "bac" "bca" "cab" "cba"
    
12. * */
    
13. public class Test4 {
    
14. 
    
15.         public static void main(String[] args){
    
16.                 //创建一个容器
    
17.                 StringBuilder sb = new StringBuilder();
    
18.                 //abc转为字符数组。
    
19.                 char[] ch = "abc".toCharArray();
    
20.                 //首先一个单个字符全排列
    
21.                 for(char i :  ch){
    
22.                        
    
23.                         System.out.print("\""+i+"\""+"\t");
    
24.                 }
    
25.                 System.out.println();
    
26.                
    
27.                 //然后取出两个两个字符。
    
28.                 for(int i=0 ;i<ch.length;i++){
    
29.                        
    
30.                         for(int j=i+1; j<ch.length;j++){
    
31.                                
    
32.                                 System.out.print("\""+ch[i]+ch[j]+"\""+"\t");
    
33.                                 sb.append(ch[i]+ch[j]+"\t");
    
34.                                 System.out.print("\""+ch[j]+ch[i]+"\""+"\t");       
    
35.                                 sb.append(ch[j]+ch[i]+"\t");
    
36.                         }
    
37.                 }
    
38.                 System.out.println();
    
39.                 //取出三个字符组合
    
40.                 for(int i=0 ;i<ch.length;i++){
    
41.                        
    
42.                         for(int j=0; j<ch.length;j++){
    
43.                                
    
44.                                 for(int k=0;k<ch.length;k++){
    
45.                                        
    
46.                                        
    
47.                                         if(ch[i]!=ch[j]&&ch[i]!=ch[k]&&ch[j]!=ch[k]){
    
48.                                                
    
49.                                                 System.out.print("\""+ch[i]+ch[j]+ch[k]+"\""+"\t");
    
50.                                         }
    
51.                                 }
    
52.                         }
    
53.                 }
    
54.                
    
55.         }
    
56. }
    

复制代码

姿_`态 发表于 2015-1-6 13:14

你这种太具体了，只针对了长度为3的字符串，要是能让用户输入的呢？

姿_`态 发表于 2015-1-6 13:14

我对题目的理解是abc只是举的一个例子,题的意思是不管输入多少理论上都成立 即输入abcd的时候也能列出"a"..."ab"..."abc"..."abcd"...因为不知道要循环多少次所以需要用到递归单纯的循环肯定不行

jant60 发表于 2015-1-6 12:44
你可以用递归，获取长度，比如第一次是3，进行一次全排列，然后调用自身，长度改为2，全排列，依次类推 ...

大概懂了，我试一下:lol

搞了好几个小时，终于是搞出来了

1. package com.itheima;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. import java.util.Scanner;
   
6. 
   
7. public class MyTest7 {
   
8. 
   
9.         private static char[] cs;
   
10.         private static List<String> list = new ArrayList<String>();
    
11.         /**
    
12.          * @param args
    
13.          */
    
14.         public static void main(String[] args) {
    
15.                 // TODO Auto-generated method stub
    
16.                 System.out.println("请输入没有重复的字符串");
    
17.                 Scanner sc = new Scanner(System.in);
    
18.                 String s = sc.next();
    
19.                 cs = s.toCharArray();
    
20.                 sc.close();
    
21.                 dealWith();
    
22.                 for(String e : list){
    
23.                         System.out.println(e);
    
24.                 }
    
25.         }
    
26.         public static void dealWith(){
    
27.                 for(int i = 0;i<cs.length;i++){                       
    
28.                         list.addAll(deal(i));
    
29.                 }
    
30.         }
    
31.        
    
32.         public static List<String> deal(int count){
    
33.                 List<String> s = new ArrayList<String>();
    
34.                 for(int i = 0; i < cs.length; i++){
    
35.                         if(count == 0){
    
36.                                 s.add(cs[i]+"");
    
37.                         }else{
    
38.                                 List<String> result = deal(count-1);
    
39.                                 for(int j = 0; j < result.size(); j++){
    
40.                                         char[] cc = result.get(j).toCharArray();
    
41.                                         boolean flag = true;
    
42.                                         for(int t = 0; t < cc.length; t++){       
    
43.                                                 if(cc[t]==cs[i]){
    
44.                                                         flag = false;
    
45.                                                         break;                                                       
    
46.                                                 }
    
47.                                         }
    
48.                                         if(flag){
    
49.                                                 s.add(cs[i]+result.get(j));
    
50.                                         }
    
51.                                 }
    
52.                         }
    
53.                 }
    
54.                 return s;
    
55.         }
    
56. }
    

复制代码

学习下....

Piaoyu 发表于 2015-1-6 16:11
学习下....

具体可以看这里，我加了注释一起学习，一起探讨