如何将此递归函数转换为迭代

Question

我想用迭代版本替换这个函数。 我发现了一些接受唯一输入的版本。

private static void FindCombinations(char[] A, string output, ref int counter, int i, int n, int k)
{
    //Console.WriteLine($"i:{i} n:{n} k:{k} r:{output}");
    if (k == 0)
    {
        Console.WriteLine(output);
        counter++;
        return;
    }

    for (int j = i; j < n; j++)
    {
        FindCombinations(A, output + " " + A[j].ToString(), ref counter, j + 1, n, k - 1);
        while (j < n - 1 && A[j] == A[j + 1])
            j++;
    }
}
private static void Main(string[] args)
{
    string output = "";
    char[] keys = new char[] { 'A', 'A', 'B', 'C', 'D' };
    int count = 0;
    FindCombinations(keys, output, ref count, 0, keys.Length, 3);
    Console.WriteLine(count.ToString());
    Console.ReadKey();
}

Answer 1

下一次，你必须首先提供你的代码尝试，因为这个社区不是为你编程，而是试图帮助你编程。此外，我们将非常感谢您提供更多上下文。

无论如何，我认为下面的这种方法应该适合你。检查它是否适用于许多不同的情况，特别是边界条件。当然，这段代码可以优化（我只是试图模仿你的递归方法的作用），但由于你只是要求非递归代码，它应该就足够了：

 private static void FindCombinations2(char[] A, string output, ref int counter, int i, int n, int k)
        {
            i = Math.Max(i, 0);
            n = Math.Min(A.Length, n);
           
            char[] A_used = new char[n - i];
            Array.Copy(A, i, A_used, 0, n - i);

            int[] indexVect = new int[k];
            for (int j = 0; j < indexVect.Length; j++)
                indexVect[j] = j;

            int L = A_used.Length;

            string currentBase = output;
            int movingIndex = 0;
            while (true)
            {
                int indexA = indexVect[movingIndex];

                if (indexA >= L)
                {
                    indexVect[movingIndex] = movingIndex;
                    movingIndex--;                    
                    if (movingIndex < 0)
                        break;
                    currentBase = currentBase.Substring(0, currentBase.Length - 2);
                    continue;
                }

                char nextA = A_used[indexA];
                currentBase += " " + nextA;
                int t;
                for ( t= indexVect[movingIndex]+1; t< L; t++)
                {
                    if(A_used[t]!=nextA)
                    {
                        indexVect[movingIndex] = t;
                        break;
                    }
                }

                if (t >= L)
                    indexVect[movingIndex] = L;


                movingIndex++;
                if (movingIndex >= k)
                {
                    Console.WriteLine(currentBase);
                    counter++;
                    movingIndex--;
                    currentBase = currentBase.Substring(0, currentBase.Length - 2);
                }
                else
                    indexVect[movingIndex] = Math.Max(indexVect[movingIndex], indexA+1);
            }
            
        }