C#生成数组数组全组合：解决内存不足与性能低效问题

核心思路 #

要解决内存溢出和速度问题，关键是避免一次性生成所有组合并存储，改用流式生成+即时处理的方式——每生成一个组合就立即输出或处理，不把所有组合保留在内存中。同时，放弃LINQ的链式调用（会产生大量中间集合开销），改用递归回溯或迭代式生成逻辑，性能和内存控制更可控。

实现方案 #

1. 递归回溯流式生成（内存占用极低） #

递归回溯是生成笛卡尔积的经典轻量方案，每次递归到最后一层时才生成当前组合并处理，全程仅用一个固定大小的字符数组存储临时数据，完全不会出现内存溢出。

public static void GenerateCombinations(char[][] arrays, Action<string> processCombination)
{
    if (arrays == null || arrays.Length == 0)
        return;

    // 预分配固定长度的字符数组，避免频繁内存分配
    char[] currentCombination = new char[arrays.Length];
    Backtrack(arrays, 0, currentCombination, processCombination);
}

private static void Backtrack(char[][] arrays, int index, char[] current, Action<string> process)
{
    if (index == arrays.Length)
    {
        // 生成字符串并即时处理（直接输出、写入文件等）
        process(new string(current));
        return;
    }

    foreach (char c in arrays[index])
    {
        current[index] = c;
        Backtrack(arrays, index + 1, current, process);
    }
}

使用示例：

char[][] input = new char[][]
{
    new char[] {'a', 'b'},
    new char[] {'1', '2'},
    // 可扩展至30个元素
};

// 示例：将每个组合输出到控制台
GenerateCombinations(input, combo => Console.WriteLine(combo));

2. 迭代式分块并行生成（适合超大规模组合） #

如果总组合数极大且需要利用多核加速，可以采用索引映射+分块并行的方式：先计算每个组合对应的索引，再将总索引范围分成多个块，每个线程独立处理一个块的组合，避免线程切换开销。

// 计算总组合数（用ulong避免整数溢出）
public static ulong CalculateTotalCombinations(char[][] arrays)
{
    ulong total = 1;
    foreach (var arr in arrays)
    {
        checked
        {
            total *= (ulong)arr.Length;
        }
    }
    return total;
}

// 根据索引生成对应组合
public static void GenerateCombinationByIndex(char[][] arrays, ulong index, char[] buffer)
{
    ulong remaining = index;
    for (int i = arrays.Length - 1; i >= 0; i--)
    {
        var arr = arrays[i];
        int elementIndex = (int)(remaining % (ulong)arr.Length);
        buffer[i] = arr[elementIndex];
        remaining /= (ulong)arr.Length;
    }
}

// 并行分块处理示例
public static void ParallelGenerateCombinations(char[][] arrays, Action<string> processCombination)
{
    ulong total = CalculateTotalCombinations(arrays);
    if (total == 0) return;

    // 每个块处理10000个组合，可根据机器性能调整
    ulong blockSize = 10000;
    ulong blockCount = (total + blockSize - 1) / blockSize;

    Parallel.For(0, (long)blockCount, blockIndex =>
    {
        ulong start = (ulong)blockIndex * blockSize;
        ulong end = Math.Min(start + blockSize, total);
        char[] buffer = new char[arrays.Length];

        for (ulong i = start; i < end; i++)
        {
            GenerateCombinationByIndex(arrays, i, buffer);
            processCombination(new string(buffer));
        }
    });
}

关键优化点 #

• 预分配内存：使用固定长度的char[]存储临时组合，避免每次生成字符串时重复分配内存。
• 无中间集合：递归/迭代逻辑全程没有生成中间集合，内存占用仅为单个组合的大小。
• 并行分块：不为单个组合开线程，而是分块处理，大幅降低线程切换的性能开销。
• 即时处理：生成一个组合就立即处理，彻底杜绝内存溢出风险。

注意事项 #

如果每个char[]的长度过大，总组合数可能会超出ulong的范围（比如30个长度为10的数组，总组合数为10^30），这种情况下无法遍历所有组合，只能通过抽样或业务逻辑裁剪范围。

内容的提问来源于stack exchange，提问作者teste