Java实现数列的排列组合

定义：

• 排列：从给定个数的元素中取出指定个数的元素，进行排序
• 组合：从给定个数的元素中仅取出指定个数的元素，不考虑排序

公式：

• 从n个元素中取出m个元素进行排序的个数：

  A(m,n)=n(n-1)(n-2)...(n-m+1)=n!/(n-m)!

• 从n个元素中取出m个元素进行组合的个数：

  C(m,n)=n!/[m!*(n-m)!]

• 注意：

  0！=1

代码实现：

计算阶乘，排列数，组合数

/**
 *  计算n的阶乘：n! = n * (n-1) * (n-2) * ... *2 * 1
*/
public static long factorial(int n){
    return (n>1) ? n*factorial(n-1) : 1;
}

/**
 *  计算排列数：A(n, m) = n!/(n-m)!  -- 从n个数中取出m个数进行排列 ,需要考虑数的顺序 (如果n个数进行排列，有n!种情况)
*/
public static long arrangement(int n, int m){
    return (n >= m) ? factorial(n)/factorial(n-m) : 0;
}

/**
 *  计算组合数：C(n, m) = n!/((n-m)! * m!)  --  从n个数中取出m个数进行排列 ,不考虑数的顺序 （如 1234 和 4321 属于一种组合，都包含1，2，3，4这四个数）
*/
public static long combination(int m, int n){
    return (n >= m) ? factorial(n)/(factorial(n-m)*factorial(m)) : 0;
}

穷举出所有的排列结果

/**
 *  排列：从数组a中选择n个数进行排列
*/
public static void arrangementSelect(int[] a, int n){
    System.out.println(String.format("A(%d, %d) = %d", a.length, n, arrangement(a.length, n)));
    arrangementSort(a, new int[n], 0);
}

/**
 * 通过递归的方式罗列出所有的排列结果
 * @param a：初始数组
 * @param result：排列数组初始状态
 * @param resultIndex：比较的起始索引
*/
public static void arrangementSort(int[] a, int[] result, int resultIndex){
    int result_length = result.length;
    if(resultIndex >= result_length){
        System.out.println(Arrays.toString(result));  // 输出排列结果
           return;
        }
    for(int i=0; i<a.length; i++){
        // 判断待选的数是否存在于排列的结果中
        boolean exist = false;
        for(int j=0; j<resultIndex; j++){
            if(a[i] == result[j]){  // 若已存在，则不能重复选
                exist = true;
                break;
            }
        }
        if(!exist){  // 若不存在，则可以选择
            result[resultIndex] = a[i];
            arrangementSort(a, result, resultIndex+1);
        }
    }
}

穷举出所有的组合结果

/**
 *  组合：从数组a中选择n个数进行组合
*/
public static void combinationSelect(int a[], int n){
    System.out.println(String.format("C(%d, %d)= %d", a.length, n, combination(a.length, n)));
    combinationSort(a, 0, new int[a.length], 0);
}

/**
 * 通过递归的方式罗列出所有的组合结果
 * @param a：初始数组
 * @param a_index：初始数组起始下标
 * @param result：初始组合数组
 * @param r_index：初始组合数组的起始下标
*/
public static void combinationSort(int[] a, int a_index, int[] result, int r_index){
    int r_len = result.length;
    int r_count = r_index + 1;
    if(r_count > r_len){
        System.out.println(Arrays.toString(result));  // 输出组合结果
        return;
    }
    for(int i=a_index; i<a.length+r_count-r_len; i++){
        result[r_index] = a[i];
        combinationSort(a, i+1, result, r_index+1);
    }
}

完整代码

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4};  // 初始数组
        arrangementSelect(a, 4);
        combinationSelect(a, 3);
    }

    /**
     *  计算n的阶乘：n! = n * (n-1) * (n-2) * ... *2 * 1
     */
    public static long factorial(int n){
        return (n>1) ? n*factorial(n-1) : 1;
    }

    /**
     *  计算排列数：A(n, m) = n!/(n-m)!  -- 从n个数中取出m个数进行排列 ,需要考虑数的顺序 (如果n个数进行排列，有n!种情况)
     */
    public static long arrangement(int n, int m){
        return (n >= m) ? factorial(n)/factorial(n-m) : 0;
    }

    /**
     *  计算组合数：C(n, m) = n!/((n-m)! * m!)  --  从n个数中取出m个数进行排列 ,不考虑数的顺序 （如 1234 和 4321 属于一种组合，都包含1，2，3，4这四个数）
     */
    public static long combination(int m, int n){
        return (n >= m) ? factorial(n)/(factorial(n-m)*factorial(m)) : 0;
    }

    /**
     *  排列：从数组a中选择n个数进行排列
     */
    public static void arrangementSelect(int[] a, int n){
        System.out.println(String.format("A(%d, %d) = %d", a.length, n, arrangement(a.length, n)));
        arrangementSort(a, new int[n], 0);
    }

    /**
     * 通过递归的方式罗列出所有的排列结果
     * @param a：初始数组
     * @param result：排列数组初始状态
     * @param resultIndex：比较的起始索引
     */
    public static void arrangementSort(int[] a, int[] result, int resultIndex){
        int result_length = result.length;
        if(resultIndex >= result_length){
            System.out.println(Arrays.toString(result));  // 输出排列结果
            return;
        }
        //
        for(int i=0; i<a.length; i++){
            // 判断待选的数是否存在于排列的结果中
            boolean exist = false;
            for(int j=0; j<resultIndex; j++){
                if(a[i] == result[j]){  // 若已存在，则不能重复选
                    exist = true;
                    break;
                }
            }
            if(!exist){  // 若不存在，则可以选择
                result[resultIndex] = a[i];
                arrangementSort(a, result, resultIndex+1);
            }
        }
    }

    /**
     *  组合：从数组a中选择n个数进行组合
     */
    public static void combinationSelect(int a[], int n){
        System.out.println(String.format("C(%d, %d)= %d", a.length, n, combination(a.length, n)));
        combinationSort(a, 0, new int[a.length], 0);

    }

    /**
     * 通过递归的方式罗列出所有的组合结果
     * @param a：初始数组
     * @param a_index：初始数组起始下标
     * @param result：初始组合数组
     * @param r_index：初始组合数组的起始下标
     */
    public static void combinationSort(int[] a, int a_index, int[] result, int r_index){
        int r_len = result.length;
        int r_count = r_index + 1;
        if(r_count > r_len){
            System.out.println(Arrays.toString(result));  // 输出组合结果
            return;
        }
        for(int i=a_index; i<a.length+r_count-r_len; i++){
            result[r_index] = a[i];
            combinationSort(a, i+1, result, r_index+1);
        }
    }
}

运行结果：

A(4, 4) = 24
[1, 2, 3, 4]
[1, 2, 4, 3]
[1, 3, 2, 4]
[1, 3, 4, 2]
[1, 4, 2, 3]
[1, 4, 3, 2]
[2, 1, 3, 4]
[2, 1, 4, 3]
[2, 3, 1, 4]
[2, 3, 4, 1]
[2, 4, 1, 3]
[2, 4, 3, 1]
[3, 1, 2, 4]
[3, 1, 4, 2]
[3, 2, 1, 4]
[3, 2, 4, 1]
[3, 4, 1, 2]
[3, 4, 2, 1]
[4, 1, 2, 3]
[4, 1, 3, 2]
[4, 2, 1, 3]
[4, 2, 3, 1]
[4, 3, 1, 2]
[4, 3, 2, 1]
C(4, 3)= 0
[1, 2, 3, 4]

Process finished with exit code 0

研读来自：https://cgs1999.iteye.com/blog/2327664