这是入学测试题：

编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如：
原始字符串是"abc"，打印得到下列所有组合情况：
"a" "b" "c"
"ab" "bc" "ca" "ba" "cb" "ac"
"abc" "acb" "bac" "bca" "cab" "cba"



我现在能输出：
"a" "b" "c"
"ab" "ac" "ba" "bc" "ca" "cb"
"abc" "acb" "bac" "bca" "cab" "cba"


算不算没达到要求啊？？

额。。。他的要求是随意输出一个字符串输出他的全排列组合

我 没做到入学测试呢，这里看了下楼主的题  说说我的思路： 的到的结果是从1个字符开始的并且 最长的情况不能大于原始字符串的长度，那么 楼主就可以根据长度 的 不断增加分别得出 每个长度下的字符组合  进而得出所有组合，  代码由于我还在上班。。。根据这个思路 代码也应该能写出来。  不知论坛其他大神有何高见

这是我的基础题~~汗~~~~~

得，我也遇到这道题了，确实自己没想出来。。。好受打击呀

http://bbs.itheima.com/thread-113625-1-1.html

发现了这一题论坛的链接

我也遇到这题了，百度的

有点难，关键要找出规律，今晚好好想想

基础题测试得了9分多 这题应该算是对了

提供一下自己的思路

1. package com.itheima;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Iterator;
   
5. import java.util.LinkedList;
   
6. import java.util.TreeSet;
   
7. 
   
8. /**
   
9. * 第8题：编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如： 原始字符串是"abc"，打印得到下列所有组合情况： "a" "b" "c"
   
10. * "ab" "bc" "ca" "ba" "cb" "ac" "abc" "acb" "bac" "bca" "cab" "cba"
    
11. */
    
12. 
    
13. public class Test8 {
    
14. 
    
15.         // 计算应该排列的数量(此函数可省)
    
16.         // 比如有4个字符时是：A41+A42+A43+A44=4+4*3+4*3*2+4*3*2*1，其中A43=A44
    
17.         private static int getCount(int length, int l, int count) {
    
18.                 int c1 = 1;
    
19.                 for (int i = length; i >= l; i--) {
    
20.                         c1 = c1 * i;
    
21.                 }
    
22.                 l--;
    
23.                 if (l == 1) {
    
24.                         count = count + c1 + c1;
    
25.                         // System.out.println(length+" "+l+" "+count);
    
26. 
    
27.                         return count;
    
28.                 } else {
    
29.                         count = count + c1;
    
30.                         // System.out.println(length+" "+l+" "+count);
    
31.                         return getCount(length, l, count);
    
32.                 }
    
33.         }
    
34. 
    
35.         // 排列
    
36.         private static void getPermutation(LinkedList<Character> list, String str,
    
37.                         ArrayList<String> arr) {
    
38. 
    
39.                 LinkedList<Character> list1 = (LinkedList<Character>) list.clone();
    
40.                 String str1;
    
41. 
    
42.                 // 以初始str+list内剩余c进行字符串连接，循环遍历
    
43.                 for (int j = 0; j < list.size(); j++) {
    
44.                         char c = list.get(j);
    
45.                         System.out.print(str + c + " ");
    
46.                         arr.add(str + c);
    
47.                 }
    
48. 
    
49.                 // 在list内循环选c，去除选定的c，递归
    
50.                 for (int i = 0; i < list1.size(); i++) {
    
51.                         str1 = str + list1.get(i);
    
52.                         list1.remove(i);
    
53.                         getPermutation(list1, str1, arr);
    
54.                         list1 = (LinkedList<Character>) list.clone();
    
55.                 }
    
56. 
    
57.         }
    
58. 
    
59.         public static void main(String[] args) {
    
60. 
    
61.                 String srcString = "abc";
    
62. 
    
63.                 int length = srcString.length();
    
64.                 int count = getCount(length, length, 0);
    
65.                 System.out.println("应该有：" + count + "种情况");
    
66. 
    
67.                 LinkedList<Character> list = new LinkedList<Character>();
    
68.                 ArrayList<String> arr = new ArrayList<String>();
    
69.                 for (int i = 0; i < length; i++) {
    
70.                         list.add(srcString.charAt(i));
    
71.                 }
    
72. 
    
73.                 System.out.println("生成顺序：");
    
74.                 getPermutation(list, "", arr);
    
75.                 System.out.println();
    
76. 
    
77.                 System.out.println("按需求输出：");
    
78.                 for (int i = 0, j = 1, count1 = 0; count1 < arr.size(); i++) {
    
79.                         if (i >= arr.size()) {
    
80.                                 i = 0;
    
81.                                 j++;
    
82.                                 System.out.println();
    
83.                         } else {
    
84.                                 if ((arr.get(i)).length() == j) {
    
85.                                         System.out.print("\"" + arr.get(i) + "\" ");
    
86.                                         count1++;
    
87.                                 }
    
88.                         }
    
89.                 }
    
90. 
    
91.         }
    
92. 
    
93. }
    

复制代码

应该有：64种情况
生成顺序：
a b c d ab ac ad abc abd abcd abdc acb acd acbd acdb adb adc adbc adcb ba bc bd bac bad bacd badc bca bcd bcad bcda bda bdc bdac bdca ca cb cd cab cad cabd cadb cba cbd cbad cbda cda cdb cdab cdba da db dc dab dac dabc dacb dba dbc dbac dbca dca dcb dcab dcba
按需求输出：
"a" "b" "c" "d"
"ab" "ac" "ad" "ba" "bc" "bd" "ca" "cb" "cd" "da" "db" "dc"
"abc" "abd" "acb" "acd" "adb" "adc" "bac" "bad" "bca" "bcd" "bda" "bdc" "cab" "cad" "cba" "cbd" "cda" "cdb" "dab" "dac" "dba" "dbc" "dca" "dcb"
"abcd" "abdc" "acbd" "acdb" "adbc" "adcb" "bacd" "badc" "bcad" "bcda" "bdac" "bdca" "cabd" "cadb" "cbad" "cbda" "cdab" "cdba" "dabc" "dacb" "dbac" "dbca" "dcab" "dcba"

LZ不是都实现了吗...只是顺序不同就不可以，你以为谁跟你有仇啊...

桃华月禅 发表于 2014-12-2 11:35
LZ不是都实现了吗...只是顺序不同就不可以，你以为谁跟你有仇啊...

输出结果顺序不同 说明递归方法不同
这题考的是递归方法 由结果写算法 一定是这样:)

好难！！！

学习了。。。

还好吧  一半