1. import java.util.Arrays;
   
2. 
   
3. public class Test {
   
4.         public static void main(String[] args) {
   
5.                 new Test().print("abc");
   
6.         }
   
7. 
   
8.         public void print(String str) {
   
9.                 char[] c = str.toCharArray();
   
10.                 int length = str.length();
    
11.                 for (int i = 1; i <= length; i++) {
    
12.                         printByNumber(c, i, "");
    
13.                         System.out.println();
    
14.                 }
    
15.         }
    
16. 
    
17.         private void printByNumber(char[] c, int num, String str) {
    
18.                 if (num == 1) {
    
19.                         for (int i = 0; i < c.length; i++) {
    
20.                                 System.out.print("\"" + str + c[i] + "\" ");
    
21.                         }
    
22.                 } else {
    
23.                         for (int i = 0; i < c.length; i++) {
    
24.                                 char[] temp = new char[c.length - 1];
    
25.                                 int index = 0;
    
26.                                 for (int j = 0; j < c.length; j++) {//刚开始把j!=i直接写在for的表达式2位置了，一直不执行for，我也真是日了狗了......
    
27.                                         if (j != i) {
    
28.                                                 temp[index++] = c[j];
    
29.                                         }
    
30.                                 }
    
31.                                 printByNumber(temp, num - 1, str + c[i]);
    
32.                         }
    
33.                 }
    
34.         }
    
35. 
    
36. }
    

复制代码

自己写的，希望对你有帮助。

哔哩哔哩 发表于 2015-4-23 22:49
自己写的，希望对你有帮助。

非常感谢

字符串的问题还没懂，表示飘过~~~

哔哩哔哩 发表于 2015-4-23 22:49
自己写的，希望对你有帮助。

思路简单有效率，学习了大神！

我跟你说说思路

1.用个外层循环控制字符串的长度，比如一个字符串有5位，那么共有5种情况对应不同长度的字符串
2.内层循环是从第一位起，截取相应长度的字符串（如果长度不够，则顺延到第一位）。每次循环后都会把第一位移向下一位
3.把截取到的字符串反转
4.打印截取到的字符串以及反转后的字符串

我_杰仔 发表于 2015-4-23 23:52
我跟你说说思路

1.用个外层循环控制字符串的长度，比如一个字符串有5位，那么共有5种情况对应不同长度的字 ...

非常感谢

Imtonoo 发表于 2015-4-23 23:47
这也太难了吧

看懂了，就会觉得很简单的

大圈套小圈

哔哩哔哩 发表于 2015-4-23 22:49
自己写的，希望对你有帮助。

哥们儿，你这个代码贴上来怎么这么漂亮啊，怎么弄的，求指点

这是我借鉴论坛一位同学写的代码，希望有用，代码插入功能是<>图标那个

1. import java.util.*;
   
2. import java.io.*;
   
3. 
   
4. public class Test5
   
5. {
   
6.         public static int count = 0;
   
7.         public static void main(String[] args)throws IOException
   
8.         {
   
9.                 //新建一个TreeSet用于存储排列后的组合，并提供一个自定义的比较器
   
10.                 TreeSet<String> set = new TreeSet<String>(new MyComp());
    
11.                
    
12.                 //接收键盘输入的字符串
    
13.                 String line = new Scanner(System.in).nextLine();
    
14.                
    
15.                 //调用函数
    
16.                 getDiff("",line,set);
    
17.                
    
18.                 //遍历集合，输出元素
    
19.                 Iterator<String> it = set.iterator();
    
20.                 int i = 1;
    
21.                 while(it.hasNext())
    
22.                 {
    
23.                         String s = it.next();
    
24.                        
    
25.                         //换行
    
26.                         if(s.length() > i)
    
27.                         {
    
28.                                 System.out.println();
    
29.                                 i++;
    
30.                         }
    
31.                        
    
32.                         //按格式输出元素
    
33.                         System.out.print("\""+s+"\"");
    
34.                        
    
35.                 }
    
36.         }
    
37.        
    
38.         /*
    
39.          * 整体的思维方式是，将串分成两部分，一部分为前缀，即 不需要修改的，另外一部分是剩下的串，
    
40.          * 如果剩下的串的长度为1，那么构成规则便只有一种，就是前缀+剩下的长度为1的串，存入TreeSet中，之所以使用TreeSet是因为可以过滤掉重复的元素，而且可以通过重写比较器进行排序.
    
41.          * 否则，便可以将剩下的串进行再次分割，将剩下的串的每一位拼接到前缀，递归寻找结果，并将结果存入TreeSet中.
    
42.          * @param prefix 字符串的构成前缀
    
43.          * @param strRight 剩下的字符串
    
44.          */
    
45.         private static void getDiff(String prefix,String strRight,TreeSet<String> set)
    
46.         {
    
47.                 //如果字符串的长度为1，直接添加进set中
    
48.         if(strRight.length()==1)
    
49.         {
    
50.             
    
51.                 if(!(set.contains(prefix+strRight)))
    
52.                                 set.add(prefix+strRight);
    
53.                 count++;
    
54.                 return;
    
55.         }
    
56.       
    
57.         //通过递归寻找结果
    
58.         for(int i=0;i<strRight.length();i++)
    
59.         {
    
60.                 StringBuilder sb = new StringBuilder(strRight);
    
61.                 String str = prefix+strRight.substring(i, i+1);
    
62.                 if(!(set.contains(str)))
    
63.                             set.add(str);
    
64.                 count++;
    
65.                 getDiff(str,sb.deleteCharAt(i).toString(),set);
    
66.         }
    
67.         }        
    
68.        
    
69. }
    
70. 
    
71. //自定义比较器进行排序
    
72. class MyComp implements Comparator
    
73. {
    
74.         public int compare(Object o1,Object o2)
    
75.         {
    
76.                 String str1 = (String)o1;
    
77.                 String str2 = (String)o2;
    
78.                 int num = str1.length()-str2.length();
    
79.                 if(num == 0)
    
80.                         return str1.compareTo(str2);
    
81.                 return num;
    
82.         }
    
83. }

复制代码

我表示遗憾，祝你好运

领教了！

基础题不会的能不能直接说不会啊- - 还是要弄懂了在写上去 那不是都对了吗

用递归的思想完成就可以

我也被这道题卡住了，厉害

这个很简单那 你使用循环就可以了

好长啊= =

感觉还是自己先思考一会的好，别一没思路，就HELP。

IDhmpj 发表于 2015-4-24 00:44
哥们儿，你这个代码贴上来怎么这么漂亮啊，怎么弄的，求指点

高级编辑里边有个<> 可以贴代码