一、说明
在牛客网的很多算法试题中，很多试题底层都是基于排列组合算法实现的，比如最优解、最大值等常见问题。排列组合算法有一定的难度，并不能用一般的多重嵌套循环解决，没有提前做针对性的学习和研究，考试时候肯定是事倍功半，所以今天我们专门出一篇文章来讲一下这个问题。
排列个数的计算公式如下：
组合个数的计算公式如下：
根据上面的公式，可以看到，阶乘是排列组合中经常使用阶乘的计算：
/**
* 计算阶乘数，即n! = n * (n-1) * ... * 2 * 1
* @param n
* @return
*/
private static long factorial(int n) {
return (n > 1) ? n * factorial(n - 1) : 1;
} 二、排列算法
排列（Permutation）是指将一组元素进行重新排序。
package xu.com.coder.test;
import java.util.Arrays;
/**
* 从n个数里取出m个数的排列算法实现
*/
public class PermutationTest {
public static void main(String[] args) {
String[] data = new String[]{"1", "2", "3", "4"};
permutationSelect(data, 2);
}
/**
* 排列选择（从列表中选择n个排列）
*
* @param dataList 待选列表
* @param n 选择个数
*/
public static void permutationSelect(String[] dataList, int n) {
System.out.printf("A(%d, %d) = %d%n", dataList.length, n, permutation(dataList.length, n));
permutationSelect(dataList, new String[n], 0);
}
/**
* 排列选择
*
* @param dataList 待选列表
* @param resultList 前面（resultIndex-1）个的排列结果
* @param resultIndex 选择索引，从0开始
*/
private static void permutationSelect(String[] dataList, String[] resultList, int resultIndex) {
int resultLen = resultList.length;
// 全部选择完时，输出排列结果
if (resultIndex >= resultLen) {
System.out.println(Arrays.asList(resultList));
return;
}
// 递归选择下一个
for (int i = 0; i < dataList.length; i++) {
// 判断待选项是否存在于排列结果中
boolean exists = false;
for (int j = 0; j < resultIndex; j++) {
if (dataList[i].equals(resultList[j])) {
exists = true;
break;
}
}
// 排列结果不存在该项，才可选择
if (!exists) {
resultList[resultIndex] = dataList[i];
permutationSelect(dataList, resultList, resultIndex + 1);
}
}
}
/**
* 计算排列数，即A(n, m) = n!/(n-m)!
*
* @param n
* @param m
* @return
*/
public static long permutation(int n, int m) {
return (n >= m) ? factorial(n) / factorial(n - m) : 0;
}
/**
* 计算阶乘数，即n! = n * (n-1) * ... * 2 * 1
*
* @param n
* @return
*/
public static long factorial(int n) {
return (n > 1) ? n * factorial(n - 1) : 1;
}
}
运行结果：
三、组合算法
组合（Combination）是指从一组元素中选取指定数量的元素，不考虑顺序。
package xu.com.coder.test;
/**
* 从n个数里取出m个数的组合算法实现
*/
import java.util.Arrays;
public class CombinationTest {
public static void main(String[] args) {
String[] data = new String[]{"1", "2", "3", "4"};
combinationSelect(data, 3);
}
/**
* 组合选择（从列表中选择n个组合）
*
* @param dataList 待选列表
* @param n 选择个数
*/
public static void combinationSelect(String[] dataList, int n) {
System.out.printf("C(%d, %d) = %d%n", dataList.length, n, combination(dataList.length, n));
combinationSelect(dataList, 0, new String[n], 0);
}
/**
* 组合选择
*
* @param dataList 待选列表
* @param dataIndex 待选开始索引
* @param resultList 前面（resultIndex-1）个的组合结果
* @param resultIndex 选择索引，从0开始
*/
private static void combinationSelect(String[] dataList, int dataIndex, String[] resultList, int resultIndex) {
int resultLen = resultList.length;
int resultCount = resultIndex + 1;
// 全部选择完时，输出组合结果
if (resultCount > resultLen) {
System.out.println(Arrays.asList(resultList));
return;
}
// 递归选择下一个
for (int i = dataIndex; i < dataList.length + resultCount - resultLen; i++) {
resultList[resultIndex] = dataList[i];
combinationSelect(dataList, i + 1, resultList, resultIndex + 1);
}
}
/**
* 计算阶乘数，即n! = n * (n-1) * ... * 2 * 1
*
* @param n
* @return
*/
public static long factorial(int n) {
return (n > 1) ? n * factorial(n - 1) : 1;
}
/**
* 计算组合数，即C(n, m) = n!/((n-m)! * m!)
*
* @param n
* @param m
* @return
*/
public static long combination(int n, int m) {
return (n >= m) ? factorial(n) / factorial(n - m) / factorial(m) : 0;
}
}
运行结果：
