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

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值