【NO.33】LeetCode HOT 100—78. 子集

78. 子集

78. 子集
给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示：

1 <= nums.length <= 10
-10 <= nums[i] <= 10
nums 中的所有元素 互不相同

解题

方法一：暴力破解

// 时间复杂度：O(n×2^n)，每种状态需要 O(n)O(n)O(n) 的时间来构造子集。
// 空间复杂度：O(n)
class Solution {

    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> lists = new ArrayList<>(); // 解集
        lists.add(new ArrayList<Integer>()); // 首先将空集加入解集中
        for(int i = 0; i < nums.length; i++){
            int size = lists.size(); // 当前子集数
            for(int j = 0; j < size; j++){ 
                List<Integer> newList = new ArrayList<>(lists.get(j));// 拷贝所有子集
                newList.add(nums[i]); // 向拷贝的子集中加入当前数形成新的子集
                lists.add(newList); // 向lists中加入新子集
            }
        }
        return lists;
    }
}

方法二：深度优先遍历

集合中每个元素的选和不选，构成了一个满二叉状态树，比如，左子树是不选，右子树是选，从根节点、到叶子节点的所有路径，构成了所有子集。可以有前序、中序、后序的不同写法，结果的顺序不一样。本质上，其实是比较完整的中序遍历。

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        List<Integer> temp = new ArrayList<>();

        // 中序遍历
        inOrder(ans, temp, nums, 0);
        
        return ans;
    }

    private void inOrder(List<List<Integer>> ans, List<Integer> temp, int[] nums, int index) {
        temp = new ArrayList<>(temp);
        if (index == nums.length) {
            ans.add(temp);
            return;
        }

        inOrder(ans, temp, nums, index+1);

        temp.add(nums[index]);

        inOrder(ans, temp, nums, index+1);
    }
    
}