题目链接如下：点击跳入题目获取帖
借用阳哥的字（谢谢啦！阳哥）：

活动目的：练习javaSE知识，算法题。

活动奖励：最高3个技术分

结束时间：2014年8月15日，过期提交可能获取不到技术分！

代码提交要求：将自己的源代码压缩然后提交，提交的时候设置为管理员权限，以其他方式提交的答案无效。上交源码的时候不需要将整个工程项目压缩，只需将用到的源文件压缩即可。

题目类型：JavaSE 排列组合算法。

难易程度：容易

我的解决思路：

第一步：用Scnner的方式建立一个数组。

第二步：敲一个函数实现老师的要求（排列组合）。

因为这里的题目类型是JavaSE排列组合算法，我认为老师还是重点让大家联系第二步的。故我在这只分享我第二步的思路，要得到数组里的全部元素的所有排列组合，每个人有每个人的方法。我的方法是：数组里每个元素都是从array[0],array[1]...array循环了一个，并把每一个新的数组打印，草图如下：

1. </blockquote></div>部分代码如下：</span></div><div><span style="font-size: large; line-height: 2.2em;"><div class="blockcode"><blockquote>for (int t = 0; t < i; t++) {
   
2.                                 int a = 0;
   
3.                                 for (int j = 0; j < i; j++) {
   
4.                                         if (j != t) {
   
5.                                                 a = arr[j];
   
6.                                                 arr[j] = arr[t];
   
7.                                                 arr[t] = a;
   
8.                                         }
   
9.                                         for (int n = 0; n < i; n++) {
   
10.                                                 System.out.print(arr[n]);
    
11.                                         }
    
12.                                         System.out.println();
    
13.                                 }
    
14.                         }

复制代码

希望对大家在获取那3技术分时有所帮助（抄袭没分呦，亲！）

这题我也做了很久，还是没搞出来，用递归做，算法有点复杂。

怎么又是这个题，之前被讨论过无数遍了。。。来一个增强版的

1. import java.util.ArrayList;
   
2. 
   
3. /*
   
4. * 输入N个字符,如'a','b','c'，打印出所有组合
   
5. * a b c
   
6. * ab ac bc ba bc cb
   
7. * abc acb bac bca cba cab
   
8. *
   
9. * 思路：
   
10. *   长度为n的字符串排列，是长度为n-1的每个字符串排列的末尾加上一个字符
    
11. *   比如，abc是由ab末尾加c得到的；acb是由ac末尾加c得到的。
    
12. *   因此，用一个ArrayList不断添加已得到的排列结果。当要排列长度为n的字符串时，让两个指针分别指向长度为n-1的排列在结果集合中的起止下标
    
13. */
    
14. 
    
15. public class PermuteAllLength {
    
16. 
    
17.         public static void main(String[] args) {
    
18. 
    
19.                 String s = "123";
    
20.                 printPermute(s);
    
21.         }
    
22.        
    
23.         public static void printPermute(String str) {
    
24.                 char[] candidates = str.toCharArray();
    
25.                 int len = str.length();
    
26.                 ArrayList<String> permutations = new ArrayList<String>(); // 存储排列结果
    
27.                 // 长度为1的排列，直接添加
    
28.                 for (char c : candidates) {
    
29.                         permutations.add(Character.toString(c));
    
30.                 }
    
31.                
    
32.                 // 下标指针，分别指向长度为1的字符串排列的起止位置
    
33.                 int start = 0;
    
34.                 int end = permutations.size();
    
35. 
    
36.                 // 长度2到len的排列，用循环完成
    
37.                 for (int i = 2; i <= len; i++) {
    
38.                         // 下面的二重循环，外层循环遍历长度为n-1的每一个字符串排列
    
39.                         for (; start < end; start++) {
    
40.                                 String s = permutations.get(start);
    
41.                                 // 内层循环则尝试在长度为n-1的字符串排列的尾部添加一个字符，形成一个长度为n的字符串
    
42.                                 for (char c : candidates) {
    
43.                                         // 只添加不重复的字符
    
44.                                         if (s.indexOf(c) == -1)
    
45.                                                 permutations.add(s + c);
    
46.                                 }
    
47.                         }
    
48.                         // 经过循环，start已经指向长度为n-1的字符串排列在结果集合中的起始位置
    
49.                         // 现在让end指向指向长度为n-1的字符串排列在结果集合中的终止位置
    
50.                         end = permutations.size();
    
51.                         // 开始下一次循环，处理长度为n的字符串排列
    
52.                 }
    
53.                
    
54.                 // 打印结果集合及其元素个数
    
55.                 System.out.println(permutations);
    
56. //                System.out.println(permutations.size());
    
57.                
    
58.         }
    
59. 
    
60. }
    

复制代码

fantacyleo 发表于 2014-8-14 00:17
怎么又是这个题，之前被讨论过无数遍了。。。来一个增强版的

import java.util.*;

/**
* 将一组数字、字母或符号进行排列，以得到不同的组合顺序， 例如1 2 3这三个数的排列组合有：1 2 3、1 3 2、2 1 3、2 3 1、3 1 2、3
* 2 1。 要求：用户输入一个整数（0到9）数组（数组长度大于等于3，小于10）， 那么请在控制台打印出该数组中所有成员的排列组合
*/
public class MyDemo {
        int i = 0;// 数组长度
        boolean b = false;
        int[] arr;

        public static void main(String[] args) {
                new MyDemo().Comb();
        }

        public MyDemo() {
                System.out.println("您想要几位数进行排列组合？（亲，这个数的范围是3<=X<10）");
                Scanner arrlong = new Scanner(System.in);
                i = arrlong.nextInt();
                if (i >= 3 && i < 10) {
                        arr = new int;
                        for (int j = 0; j < i; j++) {
                                int a = j + 1;
                                System.out.println("请输入第" + a + "个数！");
                                Scanner sc = new Scanner(System.in);
                                arr[j] = sc.nextInt();
                        }
                        b = true;
                } else {
                        System.out.println("亲，你调皮啦！输入的数不合法哦！");
                        b = false;
                }

        }

        public void Comb() {
                if (b) {
                        for (int t = 0; t < i; t++) {
                                int a = 0;
                                for (int j = 0; j < i; j++) {
                                        if (j != t) {
                                                a = arr[j];
                                                arr[j] = arr[t];
                                                arr[t] = a;
                                        }
                                        for (int n = 0; n < i; n++) {
                                                System.out.print(arr[n]);
                                        }
                                        System.out.println();
                                }
                        }
                }
        }

}

沿途小将 发表于 2014-8-14 07:53
import java.util.*;

/**

1. import java.util.*;
   
2. 
   
3. /**
   
4. * 将一组数字、字母或符号进行排列，以得到不同的组合顺序， 例如1 2 3这三个数的排列组合有：1 2 3、1 3 2、2 1 3、2 3 1、3 1 2、3
   
5. * 2 1。 要求：用户输入一个整数（0到9）数组（数组长度大于等于3，小于10）， 那么请在控制台打印出该数组中所有成员的排列组合
   
6. */
   
7. public class MyDemo {
   
8.         int i = 0;// 数组长度
   
9.         boolean b = false;
   
10.         int[] arr;
    
11. 
    
12.         public static void main(String[] args) {
    
13.                 new MyDemo().Comb();
    
14.         }
    
15. 
    
16.         public MyDemo() {
    
17.                 System.out.println("您想要几位数进行排列组合？（亲，这个数的范围是3<=X<10）");
    
18.                 Scanner arrlong = new Scanner(System.in);
    
19.                 i = arrlong.nextInt();
    
20.                 if (i >= 3 && i < 10) {
    
21.                         arr = new int[i];
    
22.                         for (int j = 0; j < i; j++) {
    
23.                                 int a = j + 1;
    
24.                                 System.out.println("请输入第" + a + "个数！");
    
25.                                 Scanner sc = new Scanner(System.in);
    
26.                                 arr[j] = sc.nextInt();
    
27.                         }
    
28.                         b = true;
    
29.                 } else {
    
30.                         System.out.println("亲，你调皮啦！输入的数不合法哦！");
    
31.                         b = false;
    
32.                 }
    
33. 
    
34.         }
    
35. 
    
36.         public void Comb() {
    
37.                 if (b) {
    
38.                         for (int t = 0; t < i; t++) {
    
39.                                 int a = 0;
    
40.                                 for (int j = 0; j < i; j++) {
    
41.                                         if (j != t) {
    
42.                                                 a = arr[j];
    
43.                                                 arr[j] = arr[t];
    
44.                                                 arr[t] = a;
    
45.                                         }
    
46.                                         for (int n = 0; n < i; n++) {
    
47.                                                 System.out.print(arr[n]);
    
48.                                         }
    
49.                                         System.out.println();
    
50.                                 }
    
51.                         }
    
52.                 }
    
53.         }
    
54. 
    
55. }
    

复制代码