高效遍歷一個數組的所有排列組合情況
1. 前言
本文主要是基於Aviad P.的2篇文章:A C# List Permutation Iterator,A C# Combinations Iterator。分別介紹瞭如何遍歷排列組合情況。使用的算法不需要額外分配空間,所以比較高效。
2. 實現
public static class Iterator
{
private static void RotateLeft<T>(IList<T> sequence, int start, int count)
{
var tmp = sequence[start];
sequence.RemoveAt(start);
sequence.Insert(start + count - 1, tmp);
}
private static void RotateRight<T>(IList<T> sequence, int count)
{
var tmp = sequence[count - 1];
sequence.RemoveAt(count - 1);
sequence.Insert(0, tmp);
}
private static IEnumerable<IList<T>> Combinations<T>(IList<T> sequence, int start, int count, int choose)
{
if (choose == 0) {
yield return sequence;
}
else {
for (var i = 0; i < count; ++i) {
foreach (var comb in Combinations(sequence, start + 1, count - 1 - i, choose - 1)) {
yield return comb;
}
RotateLeft(sequence, start, count);
}
}
}
/// <summary>
/// 迭代從sequence中取出choose個元素的所有組合情況
/// 即C(n,m),n爲sequence.Count,m爲choose
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sequence"></param>
/// <param name="choose"></param>
/// <returns>注意返回的list的長度沒有縮短成choose,用戶可以只遍歷list的前choose個元素即可,或者調用Take(choose)取出前choose個元素</returns>
public static IEnumerable<IList<T>> Combinations<T>(this IList<T> sequence, int choose)
{
return Combinations(sequence, 0, sequence.Count, choose);
}
private static IEnumerable<IList<T>> Permutations<T>(IList<T> sequence, int count)
{
if (count == 1) {
yield return sequence;
}
else {
for (var i = 0; i < count; ++i) {
foreach (var perm in Permutations(sequence, count - 1)) {
yield return perm;
}
RotateRight(sequence, count);
}
}
}
/// <summary>
/// 迭代sequence所有的排列情況
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sequence"></param>
/// <returns></returns>
public static IEnumerable<IList<T>> Permutations<T>(this IList<T> sequence)
{
return Permutations(sequence, sequence.Count);
}
/// <summary>
/// 返回從字符串s中取出count個字母的所有組合情況
/// </summary>
/// <param name="s"></param>
/// <param name="count"></param>
/// <returns></returns>
public static IEnumerable<string> Combinations(this string s, int count)
{
foreach (var comb in s.ToCharArray().ToList().Combinations(count)) {
yield return string.Join(string.Empty, comb.Take(count));
}
}
/// <summary>
/// 返回字符串s的所有排列情況
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
public static IEnumerable<string> Permutations(this string s)
{
foreach (var prem in s.ToCharArray().ToList().Permutations()) {
yield return string.Join(string.Empty, prem);
}
}
}
3. 測試
foreach (var s in "abcdef".Combinations(3)) {
Console.Write("{0,-8}", s);
}
Console.WriteLine("---------------------");
foreach (var s in "abc".Permutations()) {
Console.Write("{0,-8}", s);
}
上面會輸出
abc abd abe abf acd ace acf ade adf aef bcd bce bcf bde bdf bef cde cdf cef def
---------------------
abc bac cab acb bca cba
4. 總結
這個算法完全不需要分配額外空間,直接在原空間裏進行遍歷,所以對內存比較友好。但由於遍歷過程會直接修改原數組,如果你不能接受這種情況,可以考慮在遍歷前拷貝一份,對拷貝的那個數組進行遍歷即可。