打印数组的所有子集

Question

I'm trying to print all the subsets of an array. For example:

Input: nums = [1,2]
Output:
[[1], [2], [1,2], []]

I've written a recursive approach, given that all such solutions start with a condition and the program calls itself for a sub-array. But I get a ConcurrentModificationException at for(ArrayList<Integer>subset: subsets2) .

How to fix the issues and convert it to a working solution?

UPDATE: I don't need a working solution. I need to fix my own code. Please work on my own code below:

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

public class TestPractice {
    public static void main(String[] args){
        int[] x = {1,2};
        System.out.println(subsets(x));
    }
    
    public static List<ArrayList<Integer>> subsets(int[] nums) {
        ArrayList<ArrayList<Integer>> subsets = new ArrayList<ArrayList<Integer>>();
        if (nums.length ==1){
            ArrayList<Integer> subset1 = new ArrayList<Integer>();
            ArrayList<Integer> subset2 = new ArrayList<Integer>();
            subset2.add(nums[0]);
            subsets.add(subset1);
            subsets.add(subset2);
            return subsets;
        }
        int[] nums_1 = new int[nums.length-1];
        for(int i = 0; i< nums.length-1; i++) {
        nums_1[i]=nums[i];
        }
        
        List<ArrayList<Integer>> subsets2= subsets(nums_1); 
        //now add nums[n] to all subsets of nums[0:n-1]
        for(ArrayList<Integer>subset: subsets2) {
            ArrayList<Integer> subset1 = new ArrayList<Integer>();
            subset1.add(nums[nums.length-1]);
            subset1.addAll(subset);
            subsets2.add(subset1);
        }
        return subsets2;
    }
    
    
}

Answer 1

Don't add elements to a List when you're iterating over it. Your code can be greatly simplified by only choosing to either take or not take the current element each time. Demo

public static Set<List<Integer>> subsets(Set<List<Integer>> result, ArrayList<Integer> curr, int[] nums, int idx) {
    result.add((List<Integer>)curr.clone());
    if(idx < nums.length){
         subsets(result, curr, nums, idx + 1);
         final ArrayList<Integer> next = (ArrayList<Integer>) curr.clone();
         next.add(nums[idx]);
         subsets(result, next, nums, idx + 1);
    }
    return result;
}
public static void main(String[] args){
    int[] x = {1,2};
    System.out.println(subsets(new HashSet<>(), new ArrayList<>(), x, 0));
}

You can also use bitmasking. Demo

public static Set<List<Integer>> subsets(int[] nums) {
      final Set<List<Integer>> result = new HashSet<>();
      for(int i = 0; i < 1 << nums.length; i++){
         final List<Integer> curr = new ArrayList<>();
         for(int j = 0; j < nums.length; j++){
            if(((i>>j)&1)==1) curr.add(nums[j]);
         }
         result.add(curr);
      }
      return result;
}
public static void main(String[] args){
    int[] x = {1,2,};
    System.out.println(subsets(x));
}

Answer 2

It can be solved using both, Iterative and Recursive Approach

• For this problem using LinkedList is faster as compared to ArrayList
• Also, you don't need to handle the case when nums.length == 1

Iterative Approach

import java.util.LinkedList;
import java.util.List;

public class TestPractice {
    public static void main(String[] args) {
        int[] x = { 1, 2 };
        System.out.println(subsets(x));
    }

    public static List<LinkedList<Integer>> subsets(int[] nums) {
        LinkedList<LinkedList<Integer>> subsets = new LinkedList<LinkedList<Integer>>();
        subsets.add(new LinkedList<Integer>());
        for(int i = 0; i < nums.length; i++) {

            LinkedList<LinkedList<Integer>> temp = new LinkedList<LinkedList<Integer>>();
            for(LinkedList<Integer> l1: subsets) {
                LinkedList<Integer> l2 = new LinkedList<Integer>(l1);
                l2.add(nums[i]);
                temp.add(l2);
            }
            subsets.addAll(temp);
        }

        return subsets;
    }
}

Recursive Approach

import java.util.LinkedList;
import java.util.List;

public class TestPractice {
    public static void main(String[] args) {
        int[] x = { 1, 2 };
        System.out.println(subsets(x));
    }

    public static List<List<Integer>> subsets(int n[]) {
        List<List<Integer>> subsets = new LinkedList<List<Integer>>();
        helper(n, 0, subsets, new LinkedList<Integer>());
        return subsets;
    }

    public static void helper(int[] n, int i, List<List<Integer>> subsets, LinkedList<Integer> subset1) {
        if(i == n.length) {
            subsets.add(subset1);
            return;
        }
        helper(n, i + 1, subsets, subset1);
        LinkedList<Integer> subset2 = new LinkedList<Integer>(subset1);
        subset2.add(n[i]);
        helper(n, i + 1, subsets, subset2);
    }
}

Answer 3

concurrentmodificationexception occurs when you are looping and updating the same list, so create a new list and update that list inside the loop instead of subsets2.add(subset1) .

Below I have create a new list result and updating result list inside loop instead of subset2

import java.util.ArrayList;
import java.util.List;
public class TestPractice {
    public static void main(String[] args){
        int[] x = {1,2};
        System.out.println(subsets(x));
    }
    
    public static List<ArrayList<Integer>> subsets(int[] nums) {
        ArrayList<ArrayList<Integer>> subsets = new ArrayList<ArrayList<Integer>>();
        if (nums.length ==1){
            ArrayList<Integer> subset1 = new ArrayList<Integer>();
            ArrayList<Integer> subset2 = new ArrayList<Integer>();
            subset2.add(nums[0]);
            subsets.add(subset1);
            subsets.add(subset2);
            return subsets;
        }
        int[] nums_1 = new int[nums.length-1];
        for(int i = 0; i< nums.length-1; i++) {
        nums_1[i]=nums[i];
        }
        
        List<ArrayList<Integer>> subsets2= subsets(nums_1); 
        List<ArrayList<Integer>> result= subsets(nums_1); 
        //now add nums[n] to all subsets of nums[0:n-1]
        for(ArrayList<Integer>subset: subsets2) {
            ArrayList<Integer> subset1 = new ArrayList<Integer>();
            subset1.add(nums[nums.length-1]);
            subset1.addAll(subset);
            result.add(subset1);
        }
        return result;
    }
    
    
}