当前位置：首页 > article >正文

LeetCode100之子集(78)--Java

article 2025/1/31 2:08:01

1.问题描述

给你一个整数数组 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 中的所有元素 互不相同

难度等级

中等

题目链接

子集

2.解题思路

这道题要求所有可能的子集，这道题和求全排列那道题的不同之处在于，全排列那道题(1,2,3)和(2,1,3)是两个不同的排列，而(1,2,3)和(2,1,3)是两个相同的子集，取其中一个就可以了，所以这道题，起始比全排列那道题简单一些。

同样是使用递归+回溯的方法来解决这道题，不过这时候我们就不需要用一个标识数组来标识某个数是否已经被使用过，我们可以直接通过索引来排除掉重复的子集。每一次递归，都从当前索引的下一个数开始，这样后面的所有子集就不可能出现当前索引及其之前的数，这样就不会出现(1,2,3)和(2,1,3)同时出现的情况。

有了基本思路之后，我们就可以来实现这个基本思路，首先是定义一个存储最终答案的List集合，接着我们要来分析一下递归回溯函数该如何实现。

        //存储最终答案
        List<List<Integer>> data = new ArrayList<>();

首先，我们来确定递归的结束条件，因为我们通过索引来实现去重，索引当索引越界的时候，递归就可以结束直接返回了，因为索引越界也就代表了所有的数都已经去完了。

        //当起始索引越界时，返回
        if(startIndex >= nums.length){
            return;
        }

接着，我们来确定一下递归方法需要传入的参数。我们需要传入存储最终答案的List集合，我们还需要一个辅助List集合来帮我们存储当前子集的情况，同时还要传入题目给的数组，和递归方法的起始索引。

    public void backtrack(List<List<Integer>>data, List<Integer> list,int[] nums,int startIndex){
    .......
}

从给出的两个示例可以看出，没有元素也是一个子集，所以我们一开始就可以将空集啥也没有存入到答案List中，判断完递归的结束条件之后，我们就可以正式进入递归逻辑了(起始前面的空集存入答案List就已经是递归逻辑的一部分了)。

        //将当前子集存入答案List中
        data.add(new ArrayList<>(list));
        //当辅助list中的元素个数与nums中相等时，返回
        if(startIndex >= nums.length){
            return;
        }

我们从起始索引的位置开始遍历题目给的数组，将每一个数加入当前的子集中，接着递归调用当前的方法，求包含当前子集的其他子集，这里传入的起始索引是(i+1)，也就是当前索引+1，这样就不会取到前面的数和当前刚刚存入子集的数了。求完包含当前子集的其他子集之后，我们要将当前的数从子集中取出来进行回溯，因为包含这个数在当前位置的子集我们已经求完了，可以将它舍弃掉了。

        //从起始索引开始遍历nums数组
        for(int i = startIndex;i < nums.length;i++){
            //将数加入子集中
            list.add(nums[i]);
            //i+1，避免取到前面已经取过的数
            backtrack(data,list,nums,i+1);
            //回溯
            list.remove(list.size()-1);
        }

递归函数结束之后，我们就可以得到所有的子集了，这时直接将结果返回即可。

        //递归函数
        backtrack(data,new ArrayList<>(),nums,0);
        //返回结果
        return data;

3.代码展示

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        //存储最终答案
        List<List<Integer>> data = new ArrayList<>();
        //递归函数
        backtrack(data,new ArrayList<>(),nums,0);
        //返回结果
        return data;
    }
    public void backtrack(List<List<Integer>>data, List<Integer> list,int[] nums,int startIndex){
        //将当前子集存入答案List中
        data.add(new ArrayList<>(list));
        // 当起始索引越界时，返回
        if(startIndex >= nums.length){
            return;
        }
        //从起始索引开始遍历nums数组
        for(int i = startIndex;i < nums.length;i++){
            //将数加入子集中
            list.add(nums[i]);
            //i+1，避免取到前面已经取过的数
            backtrack(data,list,nums,i+1);
            //回溯
            list.remove(list.size()-1);
        }
    }
}