如何用迭代方式实现双列表元素的全组合配对（替代递归）

给定两个列表 l1 = [a, b, c] 和 l2 = [1, 2, 3]，我们需要生成所有可能的子列表——每个子列表包含l1中每一个元素与l2中某一元素的配对（例如 [(a,1), (b,1), (c,1)]、[(a,1), (b,1), (c,2)] 等），总共有 len(l2) ** len(l1) 种结果。以下是几种不同语言的迭代实现方案：

Python 实现方案 #

方案1：手动进制转换遍历 #

通过将每个组合映射为一个整数，再分解为len(l1)位的len(l2)进制数，每一位对应l2的索引：

l1 = ['a', 'b', 'c']
l2 = [1, 2, 3]

result = []
total_combinations = len(l2) ** len(l1)
base = len(l2)

for num in range(total_combinations):
    current_combo = []
    temp_num = num
    # 从后往前解析索引，对应l1的元素顺序
    for item in reversed(l1):
        idx = temp_num % base
        current_combo.append((item, l2[idx]))
        temp_num = temp_num // base
    # 反转回l1的原始顺序
    current_combo.reverse()
    result.append(current_combo)

# 输出前5个示例结果
for combo in result[:5]:
    print(combo)

方案2：利用标准库itertools.product #

itertools.product可以直接生成l2元素的重复笛卡尔积（重复次数为l1的长度），再与l1元素配对：

import itertools

l1 = ['a', 'b', 'c']
l2 = [1, 2, 3]

# 生成所有l2元素的重复组合，再和l1一一配对
result = [list(zip(l1, combo)) for combo in itertools.product(l2, repeat=len(l1))]

# 输出前5个示例结果
for combo in result[:5]:
    print(combo)

Java 实现方案 #

同样基于进制转换思路，手动遍历所有可能的组合：

import java.util.ArrayList;
import java.util.List;

public class ComboGenerator {
    public static void main(String[] args) {
        List<String> l1 = List.of("a", "b", "c");
        List<Integer> l2 = List.of(1, 2, 3);
        
        List<List<Pair<String, Integer>>> result = new ArrayList<>();
        int totalCombinations = (int) Math.pow(l2.size(), l1.size());
        int base = l2.size();
        
        for (int num = 0; num < totalCombinations; num++) {
            List<Pair<String, Integer>> currentCombo = new ArrayList<>();
            int tempNum = num;
            // 从后往前处理l1元素，直接插入到列表开头维持顺序
            for (int i = l1.size() - 1; i >= 0; i--) {
                int idx = tempNum % base;
                currentCombo.add(0, new Pair<>(l1.get(i), l2.get(idx)));
                tempNum = tempNum / base;
            }
            result.add(currentCombo);
        }
        
        // 打印前5个结果
        for (int i = 0; i < 5; i++) {
            System.out.println(result.get(i));
        }
    }
    
    // 自定义Pair类存储配对
    static class Pair<K, V> {
        private K key;
        private V value;
        
        public Pair(K key, V value) {
            this.key = key;
            this.value = value;
        }
        
        @Override
        public String toString() {
            return "(" + key + "," + value + ")";
        }
    }
}

这类迭代实现的核心是通过整数遍历+进制分解，避免了递归的栈深度限制，适合处理长度较长的l1列表。

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