java 实现排列组合输出

排列数

排列数基本概念

  排列数指的是从 $n$个不同元素中任取 $r(r \leq n)$个元素排成一列（考虑元素先后顺序）。排列与元素的顺序有关。
$A_n^m = n(n-1)(n-2)……(n-m+1) = \frac{n!}{(n-m)!}$

最简单的例子就是数字组合，如从 $1,2,3,4$中任取3个组合成一个三位数：

123,124,132,134,142,143
213,214,231,234,241,243
312,314,321,324,341,342
412,413,421,423,431,432

共 $A_4^3 = 24$种

代码输出所有排列方式

    /**
     * 排列选择（从列表中选择n个排列）
     * @param dataList 待选列表
     * @param n 选择个数
     */
    public static void arrangementSelect(String[] dataList, int n, List<String[]> result) {
        arrangementSelect(dataList, new String[n], 0,result);
    }

    /**
     * 排列选择
     * @param dataList 待选列表
     * @param results 前面（resultIndex-1）个的排列结果
     * @param resultIndex 选择索引，从0开始
     */
    private static void arrangementSelect(String[] dataList, String[] results, int resultIndex, List<String[]> result) {
        int resultLen = results.length;
        if (resultIndex >= resultLen) { // 全部选择完时，输出排列结果
            String [] temps = new String[resultLen];
            System.arraycopy(results, 0, temps, 0, results.length);
            result.add(temps);
//            System.out.println(Arrays.asList(temps));
            return;
        }
        // 递归选择下一个
        for (String aDataList : dataList) {
            // 判断待选项是否存在于排列结果中
            boolean exists = false;
            for (int j = 0; j < resultIndex; j++) {
                if (aDataList.equals(results[j])) {
                    exists = true;
                    break;
                }
            }
            if (!exists) { // 排列结果不存在该项，才可选择
                results[resultIndex] = aDataList;
                arrangementSelect(dataList, results, resultIndex + 1, result);
            }
        }
    }

组合数

组合数基本概念

  排列数指的是从 $n$个不同元素中任取 $r(r \leq n)$个元素排成一组（不考虑元素先后顺序）。组合与元素的顺序无关。
$C_n^m = \frac{P_n^m}{P_m} = \frac{n!}{m!(n-m)!},C_n^0 = 1$

例子：A，B，C三名工人共有 $\{A,B\}、\{A,C\}、\{B,C\}$ 3种搭配方式。

代码输出所有组合方式

	/**
    * 组合选择（从列表中选择n个组合）
    * @param dataList 待选列表
    * @param n 选择个数
    */
   public static <AnyType extends Comparable<? super AnyType>> void combinationSelect(AnyType[] dataList, int n, List<AnyType[]> result) {
       combinationSelect(dataList, 0, (AnyType[])new Comparable[n], 0,result);
   }

    /**
    * 组合选择
    * @param dataList 待选列表
    * @param dataIndex 待选开始索引
    * @param resultList 前面（resultIndex-1）个的组合结果
    * @param resultIndex 选择索引，从0开始
    */
   private static <AnyType extends Comparable<? super AnyType>> void combinationSelect(AnyType[] dataList, int dataIndex, AnyType[] resultList, int resultIndex, List<AnyType[]> result) {
       int resultLen = resultList.length;
       int resultCount = resultIndex + 1;
       if (resultCount > resultLen) { // 全部选择完时，输出组合结果
           AnyType[] temps = (AnyType[]) new Comparable[resultLen];
           System.arraycopy(resultList, 0, temps, 0, resultList.length);
           result.add(temps);
//            System.out.println(Arrays.asList(temps));
           return;
       }

       // 递归选择下一个
       for (int i = dataIndex; i < dataList.length + resultCount - resultLen; i++) {
           resultList[resultIndex] = dataList[i];
           combinationSelect(dataList, i + 1, resultList, resultIndex + 1,result);
       }
   }