/// <summary>
/// 计算Int32类型的整数的阶乘，目前最大只能对20以内的正整数求阶乘
/// </summary>
/// <param name="n">Int32类型的正整数</param>
/// <returns></returns>
public static long Factor(this int n)
{
long result = -1;
checked
{
try
{
if (n < 0)
{
result = -1;
}
else
{
if (n == 0 || n == 1)
{
result = 1;
}
else
{
result = n * (n - 1).Factor();
}
}
}
catch (OverflowException)
{
result = -1;
}
}
return result;
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
计算阶乘的递归算法，后续会用到，虽然用了long类型，但也只能计算到20的阶乘
/// <summary>
/// 计算从n个不同元素中任选m个元素的排列个数.n应该大于等于m！
/// </summary>
/// <param name="n">供排列选择的元素个数，正整数</param>
/// <param name="m">排列选取的元素个数，正整数</param>
/// <returns>排列个数</returns>
public static long Permutation(int n,int m)
{
int[] N = new int[n];
int[] SubM = new int[n-m];
long result = 0;
if (n < m)
{
result = 0;
}
else
{ //初始化数组N和M
for (int i = 0; i < n; i++)
{
N[i] = i + 1;
if (i < n - m)
{
SubM[i] = i + 1;
}
}
//消除两个数组中的重复元素
for (int i = 0; i < n - m; i++)
{
if (SubM[i] == N[i])
{
N[i] = 1;
}
}
//计算N中剩余元素的累乘
result = 1;
checked
{
try
{
for (int i = 0; i < n; i++)
{
result *= N[i];
}
}
catch (OverflowException)
{
result = -1;
}
}
}
return result;
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
计算排列数，主要思想是类似于小学数学中求分式相乘中的消除法，主要是为了避免求阶乘的限制
/// <summary>
/// 计算从n个不同元素中选取m个元素的组合个数。n应该大于等于m
/// </summary>
/// <param name="n">供组合选择的元素个数，正整数</param>
/// <param name="m">组合选取的元素个数，正整数</param>
/// <returns>组合个数</returns>
public static long Combination(int n, int m)
{
long factM = m.Factor();
long result = 0;
int[] N, M, subM;
if (n < m)
{
result = 0;
}
else
{
if (factM > 0)
{
result = Permutation(n, m) / factM;
}
else
{
N = new int[n]; M = new int[m]; subM = new int[n - m];
//初始化三个数组
for (int i = 0; i < n; i++)
{
N[i] = i + 1;
if (i < m)
{
M[i] = i + 1;
}
if (i < n - m)
{
subM[i] = i + 1;
}
}
//消除重复元素，因为当m的阶乘溢出时才会进入此分支，所以只考虑和数组M进行消除
for(int i = 0; i < m; i++)
{
if (N[i] == M[i])
{
N[i] = 1;
}
}
//计算数组N和subM的累乘
long rN = 1, rSubM = 1;
for (int i = 0; i < n; i++)
{
rN *= N[i];
if (i < n - m)
{
rSubM *= subM[i];
}
}
//计算组合个数
result = rN / rSubM;
}
}
return result;
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
计算组合数，思路和求排列数一致，不再赘述
/// <summary>
/// 获得从n个不同元素中任意选取m个元素的组合的所有组合形式的列表
/// </summary>
/// <param name="elements">供组合选择的元素</param>
/// <param name="m">组合中选取的元素个数</param>
/// <returns>返回一个包含列表的列表，包含的每一个列表就是每一种组合可能</returns>
public static List<List<T>> GetCombinationList<T>(List<T> elements,int m)
{
List<List<T>> result = new List<List<T>>();//存放返回的列表
List<List<T>> temp = null; //临时存放从下一级递归调用中返回的结果
List<T> oneList = null; //存放每次选取的第一个元素构成的列表，当只需选取一个元素时，用来存放剩下的元素分别取其中一个构成的列表；
T oneElment; //每次选取的元素
List<T> source = new List<T>(elements); //将传递进来的元素列表拷贝出来进行处理，防止后续步骤修改原始列表，造成递归返回后原始列表被修改；
int n = 0; //待处理的元素个数
if (elements != null)
{
n = elements.Count;
}
if(n==m && m != 1)//n=m时只需将剩下的元素作为一个列表全部输出
{
result.Add(source);
return result;
}
if (m == 1) //只选取一个时，将列表中的元素依次列出
{
foreach(T el in source)
{
oneList = new List<T>();
oneList.Add(el);
result.Add(oneList);
oneList = null;
}
return result;
}
for (int i = 0; i <= n - m; i++)
{
oneElment = source[0];
source.RemoveAt(0);
temp = GetCombinationList(source, m - 1);
for (int j = 0; j < temp.Count; j++)
{
oneList = new List<T>();
oneList.Add(oneElment);
oneList.AddRange(temp[j]);
result.Add(oneList);
oneList = null;
}
}
return result;
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
求所有可能的组合形式，一个递归实现，依次选择待组合元素中的前n-m个元素，每次选择后在剩下的元素中选取m-1个元素，直到m==1或者列表元素个数等于m则停止递归
