如何递归打印数组前n个整数的所有子集？（附示例）

我明白你现在卡在这个递归打印子集的问题上了，先别急，我们先拆解一下示例的规律，再调整你的代码。

问题分析 #

你需要的不是传统的子集输出顺序，而是从数组最右侧元素开始，依次向左处理每个元素：先输出当前元素的单个子集，再输出当前元素与右侧所有子集拼接后的结果。以示例[1,2,3]（n=3）为例：

• 先处理最右侧的3 → 输出3
• 再处理中间的2 → 输出2、23
• 最后处理最左侧的1 → 输出1、13、12、123
  最终组合起来就是示例要求的输出：[3,2,23,1,13,12,123]

修正后的代码实现 #

这里提供两种清晰的实现方式，你可以根据自己的习惯选择：

方式1：先收集所有组合再打印（逻辑最清晰）

这种方式先通过递归收集符合顺序的所有子集字符串，再逐个打印，非常容易理解：

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

public class SubsetPrinter {
    public static void main(String[] args) {
        int[] X = {1, 2, 3, 4};
        subsets(X, 3); // 输出示例要求的结果
    }

    static void subsets(int[] A, int n) {
        List<String> combinations = getCombinations(A, n);
        for (String combo : combinations) {
            System.out.println(combo);
        }
    }

    // 递归收集前k个元素的所有符合顺序的子集字符串
    private static List<String> getCombinations(int[] A, int k) {
        List<String> result = new ArrayList<>();
        if (k == 0) {
            return result; // 终止条件：没有元素时返回空列表
        }

        // 1. 先收集前k-1个元素的所有组合（保证右侧元素的组合先出现）
        List<String> prevCombos = getCombinations(A, k - 1);
        result.addAll(prevCombos);

        // 2. 添加当前元素的单个子集
        String current = String.valueOf(A[k - 1]);
        result.add(current);

        // 3. 添加当前元素与前k-1个每个组合拼接后的结果
        for (String combo : prevCombos) {
            result.add(current + combo);
        }

        return result;
    }
}

方式2：直接递归打印（更贴近你的初始思路）

如果你想避免使用列表，也可以在递归中先打印右侧元素的组合，再打印当前元素和拼接结果：

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

public class SubsetPrinter {
    public static void main(String[] args) {
        int[] X = {1, 2, 3, 4};
        subsets(X, 3);
    }

    static void subsets(int[] A, int n) {
        printSubsets(A, n);
    }

    private static void printSubsets(int[] A, int k) {
        if (k == 0) {
            return; // 终止条件：没有元素时返回
        }

        // 1. 先递归打印前k-1个元素的所有组合
        printSubsets(A, k - 1);

        // 2. 打印当前元素的单个子集
        System.out.println(A[k - 1]);

        // 3. 打印当前元素与前k-1个每个组合拼接后的结果
        List<String> prevCombos = collectCombinations(A, k - 1);
        for (String combo : prevCombos) {
            System.out.println(A[k - 1] + combo);
        }
    }

    // 辅助函数：收集前k个元素的所有子集字符串
    private static List<String> collectCombinations(int[] A, int k) {
        List<String> result = new ArrayList<>();
        if (k == 0) {
            return result;
        }

        List<String> prev = collectCombinations(A, k - 1);
        result.addAll(prev);
        result.add(String.valueOf(A[k - 1]));
        for (String combo : prev) {
            result.add(String.valueOf(A[k - 1]) + combo);
        }

        return result;
    }
}

代码逻辑说明 #

两种方式的核心逻辑一致：

1. 递归终止条件：当k=0（没有元素需要处理）时返回空结果或直接返回。
2. 递归处理右侧元素：先处理并收集/打印前k-1个元素的所有组合（对应数组中更靠右的元素）。
3. 处理当前元素：先添加/打印当前元素的单个子集，再添加/打印当前元素与右侧所有子集拼接后的结果。

这样就能严格按照你示例要求的顺序输出所有子集了。

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