C# 循环正N！排列逻辑的时代？

下面的代码基本上获取字符串的排列。因此，我预计时间复杂度为

O（N！）

。 使用参数“abc”运行以下代码将显示循环36，而不是

3次数

static void Main(string[] args)
{
    generated = new HashSet<string>();
    var test = getA(args[0]);
    int i = 1;
    foreach (var s in test)
    {
        Console.WriteLine($"{i}:{s}");
        i++;
    }
}

static HashSet<string> generated;
private static IEnumerable<string> getA(string v)
{
    if (v.Length <= 1)
    {
        yield return v;
    }
    else
    {
        for (var i = 0; i < v.Length; i++)
        {
            var c = v[i];
            var s = v.Remove(i, 1);
            Console.WriteLine($"  i:{i} v:{v} c:{c} s:{s}");
            foreach (var t in getA(s))
            {
                Console.WriteLine($"      t:{t}");
                for (var k = 0; k < t.Length; k++)
                {
                    if (c != t[k])
                    {
                        var result = t.Insert(k, c.ToString());
                        //if (!generated.Contains(result))
                        {
                            generated.Add(result);
                            yield return result;
                        }
                    }
                }
                //if (!generated.Contains(t + c))
                {
                    generated.Add(t + c);
                    yield return t + c;
                }
            }
        }
    }
}

static void Main（字符串[]args）
{
生成=新的HashSet（）；
var测试=getA（参数[0]）；
int i=1；
foreach（测试中的var s）
{
Console.WriteLine（$“{i}:{s}”）；
i++；
}
}
生成静态哈希集；
私有静态IEnumerable getA（字符串v）
{
if（v.LengthBig O表示变量接近无穷大时的渐近复杂性

这并不是对将要执行的操作的确切数量的度量

当您不断增加输入大小并接近无穷大时，实际执行的操作数将不断接近“N！”