编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如：
原始字符串是"abc"，打印得到下列所有组合情况：
"a" "b" "c"
"ab" "bc" "ca" "ba" "cb" "ac"
"abc" "acb" "bac" "bca" "cab" "cba"
我的想法是：
1.先输入字符串"abc"
2,控制输出个数，每行遍历输出，第一行三个，第二行六个，第三行六个这样输出。
需要大神帮忙的是：
1，如何控制输出个数
2，遍历的时候怎么样才能没有重复字符
请各位大神提提建议指点一下小弟，小弟在此先谢过了。

这道题我也不会  共同等待大神指点

你这是测试题吗？

1. /**
   
2. *
   
3. *
   
4. * 编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如：
   
5. 原始字符串是"abc"，打印得到下列所有组合情况：
   
6. 
   
7. "a" "b" "c"
   
8. 
   
9. "ab" "bc" "ca" "ba" "cb" "ac"
   
10. 
    
11. "abc" "acb" "bac" "bca" "cab" "cba"
    
12. * @author lwh
    
13. *
    
14. */
    
15. class Test{
    
16.         public static void main(String[] args) {
    
17.                 StringBuilder str = new StringBuilder("abc");
    
18.                 Set<String> set = new TreeSet<String>();
    
19.                 char[] ch = str.toString().toCharArray();
    
20.                 print(ch, new StringBuilder(), set, 0);
    
21. 
    
22.                 System.out.println();
    
23.                 System.out.println("----------------");
    
24. 
    
25.                 Set<String> set2 = quChongFu(set);
    
26.                 Iterator<String> it2 = set2.iterator();
    
27.                 while (it2.hasNext()) {
    
28.                         System.out.print(it2.next() + " ");
    
29.                 }
    
30.         }
    
31. 
    
32.         // 去掉集合中重复的元素
    
33.         /*
    
34.          * set:需要除去重复字符元素的集合
    
35.          */
    
36.         public static Set<String> quChongFu(Set<String> set) {
    
37.                 Set<String> set2 = new TreeSet<String>();
    
38.                 Map<Character, Integer> map = null;
    
39.                 Iterator<String> it2 = set.iterator();
    
40.                 int count;
    
41.                 while (it2.hasNext()) {
    
42.                         map = new HashMap<Character, Integer>();
    
43.                         count = 1;
    
44.                         boolean flag = false;
    
45.                         String str = it2.next();
    
46.                         char[] ch = str.toCharArray();
    
47.                         for (int i = 0; i < ch.length; i++) {
    
48.                                 if (!map.containsKey(ch[i])) {
    
49.                                         count = 1;
    
50.                                         map.put(ch[i], count);
    
51.                                 }
    
52.                                 if (map.containsKey(ch[i])) {
    
53.                                         map.put(ch[i], count);
    
54.                                         count++;
    
55.                                 }
    
56. 
    
57.                         }
    
58.                         // System.out.println(map);
    
59.                         for (int j = 0; j < ch.length; j++) {
    
60.                                 if (map.get(ch[j]) > 1) {
    
61.                                         flag = false;
    
62.                                         // System.out.println("r");
    
63.                                         break;
    
64.                                 } else
    
65. 
    
66.                                         flag = true;
    
67.                         }
    
68.                         if (flag) {
    
69.                                 // System.out.println("s");
    
70.                                 set2.add(str);
    
71. 
    
72.                         }
    
73.                 }
    
74.                 // System.out.println(set2);
    
75.                 return set2;
    
76.         }
    
77. 
    
78.         // 利用递归打印所有组合
    
79.         /*
    
80.          * ch:需要打印在组合的字符数组
    
81.          * subStr:子字符串缓存，每个组合临时保存的变量
    
82.          * set:最后存入的集合
    
83.          * cout:递归的层数，和ch参数的（长度）相等
    
84.          */
    
85.         public static void print(char[] ch, StringBuilder subStr, Set<String> set,
    
86.                         int count) {
    
87.                 // 递归一层自加一次
    
88.                 count++;
    
89.                 // 当递归层数大于字符数组长度时退出
    
90.                 if (count > ch.length) {
    
91.                         return;
    
92.                 }
    
93.                 for (int i = 0; i < ch.length; i++) {
    
94.                         // 当前字符添加到缓存变量中
    
95.                         subStr.append(ch[i]);
    
96.                         // 打印所有组合，包括重复的
    
97.                         System.out.print(subStr.toString() + ",");
    
98.                         // 将缓存变量中的数据转换成字符串存入集合中
    
99.                         set.add(subStr.toString());
    
100.                         // 进入下一层，也就是字符数组的下一个字符
     
101.                         print(ch, subStr, set, count);
     
102.                         // 删除上次保存的最后一个字符，避免了字符重复
     
103.                         subStr.deleteCharAt(subStr.length() - 1);
     
104.                 }
     
105. 
     
106.         }
     
107. }

复制代码

lwh316658735 发表于 2015-2-14 18:37

大神啊，万分感谢。

guiqi225 发表于 2015-2-14 14:39
你这是测试题吗？

是的，其他的都好整，这道题不好整。

遍历的时候怎么样才能没有重复字符。。。。。。。。。。。

但疼的递归啊。。。

janstk 发表于 2015-2-15 21:11
但疼的递归啊。。。

我能说我还是菜鸟么。

又是递归啊