最近有一个问题一直困扰着我,它涉及到我的程序中循环的指数级增长。请看下面的代码并阅读注释。
void Main()
{
//Here we are just creating simple lists
List<string> strings = new List<string>();
strings.Add("a");
strings.Add("b");
strings.Add("c");
List<int> integers = new List<int>();
integers.Add(1);
integers.Add(2);
integers.Add(3);
//Creating complex classes ( not really )
ComplexClass cc1 = new ComplexClass();
cc1.CCString = "A test";
cc1.CCInt = 2;
ComplexClass cc2 = new ComplexClass();
cc2.CCString = "Another test";
cc2.CCInt = 6;
//Creating a list of these too
List< ComplexClass > complexClasses = new List< ComplexClass >();
complexClasses.Add(cc1);
complexClasses.Add(cc2);
//Here i want to create every possible combination using each of the lists
//and then add these to a testData class to do other things with, serialize, save, print etc.
//The main question is here, the for loops will definitely increase exponentially with each
//list added to.
foreach( int i in integers )
{
foreach( string s in strings )
{
foreach( ComplexClass compClass in complexClasses )
{
TestData data = new TestData();
data.TestInteger = i;
data.TestString = s;
data.TestComplexClass = compClass;
OutPutTestData( data );
}
}
}
}
//Simply outputs the data as test but I will be keeping the object for later also
public void OutPutTestData( TestData testData )
{
Console.WriteLine( testData.TestString + testData.TestInteger + testData.TestComplexClass.CCString );
}
//The "Complex class" again not that complex but an example of what im tring to achieve
public class ComplexClass
{
public string CCString{ get; set; }
public int CCInt { get; set; }
}
//The overall test object which holds multiple properties of different data types
public class TestData
{
public string TestString { get; set; }
public int TestInteger { get; set; }
public ComplexClass TestComplexClass { get; set; }
}
输出
a1 测试1
a1 测试2
b1 测试1
b1 测试2
c1 测试1
c1 测试2
a2 测试1
a2 测试2
b2 测试1
b2 测试2
c2 测试1
c2 测试2
a3 测试1
a3 测试2
b3 测试1
b3 测试2
c3 测试1
c3 测试2
如你所见,循环工作,并给出了提供数据的所有可能组合。
我的问题是 for 循环的指数增长随着我添加更多列表。可能会有大量的列表。
我确实明白,当发现组合时迭代次数将增加,这并不是问题,因为我计划根据用户的输入在估算出总迭代次数后以编程方式限制可能发生的迭代次数。
例如,总迭代次数将是234,因此仅迭代120次(120个组合)。
提供的代码在嵌套的 foreach 循环中运行良好,但随着指数增长,变得难以阅读、难以管理,一般来说也不太美观。
我查看了这些排列算法:
但它们只允许使用一个特定的数据类型而不是多个。
我还研究了笛卡尔积,但再次发现唯一的示例是指单个数据类型。