定義：
- 排列：從給定個數的元素中取出指定個數的元素，進行排序
- 組合：從給定個數的元素中僅取出指定個數的元素，不考慮排序
公式：
- 從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