mysql排列组合实现_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
// 判斷待選的數是否存在于排列的結果中
boolean exist = false;
for(int j=0; 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
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
// 判斷待選的數是否存在于排列的結果中
boolean exist = false;
for(int j=0; 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
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
總結
以上是生活随笔為你收集整理的mysql排列组合实现_Java实现数列的排列组合的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： django设置mysql数据库连接_d
- 下一篇： mysql数据回滚占用id吗_mysql