输出 N 个数字可以组成的所有组成方式，并输出组合的总数。

1. public final class Main {
   
2.     public static void main(final String args[]) throws Throwable {
   
3.         final int N = 4;
   
4.         final int count = Main.list(N);
   
5.         System.out.println(N + " 个数字可以组成 " + count + " 种组合.");
   
6.     }
   
7. 
   
8.     /**
   
9.      * 打印 n 个数字可以组成的所有组合，并返回组合的总数
   
10.      * @param n 有几个数字
    
11.      * @return 组合的数量
    
12.      */
    
13.     public static int list(final int n) {
    
14.         // 生成一个临时数组包含 (0) ~ (n - 1) 的所有数字
    
15.         final Integer[] arr = new Integer[n];
    
16.         for (int i = 0; i < n; i++) {
    
17.             arr[i] = i;
    
18.         }
    
19.         
    
20.         // 调用 list 方法来打印所有组合
    
21.         return Main.list(arr, 0);
    
22.     }
    
23. 
    
24.     /**
    
25.      * 打印一些元素可以组成的组合数量
    
26.      * @param arr 元素列表
    
27.      * @param i 当前递归的位置，调用时请传 0
    
28.      * @return 组合的数量
    
29.      */
    
30.     public static <T> int list(final T[] arr, final int i) {
    
31.         // 如果当前元素是最后一个元素
    
32.         if (i == arr.length - 1) {
    
33.             // 打印当前组合
    
34.             for (final T t : arr) {
    
35.                 System.out.print(t);
    
36.                 System.out.print(" ");
    
37.             }
    
38.             System.out.println();
    
39. 
    
40.             return 1;
    
41.         } else {
    
42.             // 当前位置的组合总数
    
43.             int count = 0;
    
44.             // 循环将当前位置上的元素与其后的元素进行交换，然后递归调用 list 方法
    
45.             for (int j = i; j < arr.length; j++) {
    
46.                 Main.swap(arr, i, j);
    
47.                 count += Main.list(arr, i + 1);
    
48.                 Main.swap(arr, i, j);
    
49.             }
    
50. 
    
51.             // 返回当前位置的组合总数
    
52.             return count;
    
53.         }
    
54.     }
    
55. 
    
56.     /**
    
57.      * 将数组中的两个元素进行交换
    
58.      * @param array 要被交换元素的数组
    
59.      * @param i 第一个元素的下标
    
60.      * @param j 第二个元素的下标
    
61.      */
    
62.     public static <T> void swap(final T[] array, final int i, final int j) {
    
63.         final T t = array[i];
    
64.         array[i] = array[j];
    
65.         array[j] = t;
    
66.     }

复制代码

示例输出：

1. 0 1 2 3
   
2. 0 1 3 2
   
3. 0 2 1 3
   
4. 0 2 3 1
   
5. 0 3 2 1
   
6. 0 3 1 2
   
7. 1 0 2 3
   
8. 1 0 3 2
   
9. 1 2 0 3
   
10. 1 2 3 0
    
11. 1 3 2 0
    
12. 1 3 0 2
    
13. 2 1 0 3
    
14. 2 1 3 0
    
15. 2 0 1 3
    
16. 2 0 3 1
    
17. 2 3 0 1
    
18. 2 3 1 0
    
19. 3 1 2 0
    
20. 3 1 0 2
    
21. 3 2 1 0
    
22. 3 2 0 1
    
23. 3 0 2 1
    
24. 3 0 1 2
    
25. 4 个数字可以组成 24 种组合.
    

复制代码

老司机，好厉害

滴滴,学生卡

额  不是排列组合a吗    4！=24...

好复杂,好复杂啊,好复杂啊啊啊