Generate All Subsets Powerset in DSA Java

Mental Model

We find every possible group of items from a list, including empty and full groups.

Analogy: Imagine you have a box of colored beads and want to see all ways you can pick some beads or none at all.

Set: [1, 2]
Subsets:
[]
[1]
[2]
[1, 2]

Dry Run Walkthrough

Input: list: [1, 2]

Goal: Find all subsets of the list including empty and full sets

Step 1: Start with empty subset

[]

Why: We begin with no items selected

Step 2: Add 1 to existing subsets

[]
[1]

Why: Create new subsets by adding first element to existing subsets

Step 3: Add 2 to all existing subsets

[]
[1]
[2]
[1, 2]

Why: Add second element to all subsets to form new subsets

Result:

[]
[1]
[2]
[1, 2]

Annotated Code

DSA Java

import java.util.*;

public class Powerset {
    public static List<List<Integer>> generateSubsets(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        result.add(new ArrayList<>()); // start with empty subset

        for (int num : nums) {
            int size = result.size();
            for (int i = 0; i < size; i++) {
                List<Integer> newSubset = new ArrayList<>(result.get(i));
                newSubset.add(num); // add current number to existing subset
                result.add(newSubset); // add new subset to result
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[] input = {1, 2};
        List<List<Integer>> subsets = generateSubsets(input);
        for (List<Integer> subset : subsets) {
            System.out.println(subset);
        }
    }
}

result.add(new ArrayList<>()); // start with empty subset

initialize result with empty subset

for (int num : nums) {

iterate over each number in input array

int size = result.size();

record current number of subsets before adding new ones

for (int i = 0; i < size; i++) {

loop over existing subsets to create new subsets

List<Integer> newSubset = new ArrayList<>(result.get(i));

copy existing subset to create a new one

newSubset.add(num); // add current number to existing subset

add current element to new subset

result.add(newSubset); // add new subset to result

include new subset in the list of all subsets

Output

[]

[1]

[2]

[1, 2]

Complexity Analysis

Time: O(n * 2^n) because for each of the n elements, we double the number of subsets by adding the element to all existing subsets

Space: O(2^n) because the total number of subsets grows exponentially with the number of elements

vs Alternative: Compared to recursive backtracking, this iterative approach builds subsets step-by-step and is easier to understand but both have similar exponential time and space costs

Edge Cases

empty input array

returns a list with only the empty subset

DSA Java

result.add(new ArrayList<>()); // start with empty subset

single element array

returns empty subset and subset with that single element

DSA Java

for (int num : nums) {

When to Use This Pattern

When asked to find all possible combinations or groups from a set, use the powerset pattern to generate every subset by building on smaller subsets.

Common Mistakes

Mistake: Modifying the list of subsets while iterating over it without fixing the iteration size
Fix: Store the current size before the inner loop and only iterate up to that size to avoid infinite loops

Summary

Generates every possible subset of a given list including empty and full subsets.

Use when you need to explore all combinations or groupings of elements.

The key insight is to build new subsets by adding each element to all existing subsets step-by-step.

Practice

1. What does the term powerset mean in the context of subsets?

easy

A. All possible subsets of a given set, including empty and full set

B. Only the subsets with exactly two elements

C. The set of elements that are not in the original set

D. The largest subset of a given set

Solution

1. Step 1: Understand the definition of powerset

   The powerset of a set is the collection of all possible subsets, including the empty set and the set itself.

2. Step 2: Compare options with definition

   All possible subsets of a given set, including empty and full set correctly describes the powerset as all subsets. Other options describe partial or unrelated concepts.

3. Final Answer:

   All possible subsets of a given set, including empty and full set -> Option A

4. Quick Check:

   powerset = all subsets [OK]

Hint: Powerset means every subset possible, including empty [OK]

Common Mistakes:

• Thinking powerset excludes empty set
• Confusing powerset with subsets of fixed size
• Assuming powerset means complement sets

2. Which of the following Java method signatures correctly represents a function that returns all subsets of an integer array?

easy

A. public int generateSubsets(int[] nums)

B. public void generateSubsets(int[] nums)

C. public List generateSubsets(int[] nums)

D. public List<Integer> generateSubsets(int nums)

Solution

1. Step 1: Identify return type for all subsets

   All subsets of an integer array require returning a list of lists of integers, so return type should be List.

2. Step 2: Check method parameters and return type

   public List generateSubsets(int[] nums) matches correct return type and parameter. Options A and C have wrong return types, and D has wrong parameter type.

3. Final Answer:

   public List<List<Integer>> generateSubsets(int[] nums) -> Option C

4. Quick Check:

   Return type must hold all subsets = List of List [OK]

Hint: Return type for subsets is List of List of Integers [OK]

Common Mistakes:

• Using int return type instead of list
• Using void return type without output
• Passing single int instead of int array

3. What is the output of the following Java code snippet?

public static List subsets(int[] nums) {
    List result = new ArrayList<>();
    result.add(new ArrayList<>());
    for (int num : nums) {
        int size = result.size();
        for (int i = 0; i < size; i++) {
            List<Integer> subset = new ArrayList<>(result.get(i));
            subset.add(num);
            result.add(subset);
        }
    }
    return result;
}

// Called with nums = {1, 2}

medium

A. [[], [1], [2], [1, 2]]

B. [[1], [2], [1, 2]]

C. [[], [1, 2]]

D. [[1], [2]]

Solution

1. Step 1: Initialize result with empty subset

   Initially, result = [[]].

2. Step 2: Iterate over nums and add new subsets

   For num=1, add [1] to result: result = [[], [1]]. For num=2, add [2] and [1,2]: result = [[], [1], [2], [1, 2]].

3. Final Answer:

   [[], [1], [2], [1, 2]] -> Option A

4. Quick Check:

   All subsets of {1,2} = [[], [1], [2], [1, 2]] [OK]

Hint: Start with empty set, add each number to existing subsets [OK]

Common Mistakes:

• Forgetting to include empty subset
• Adding subsets in wrong order
• Missing combined subsets like [1, 2]

4. Identify the error in the following Java code that attempts to generate all subsets of an integer array:

public static List subsets(int[] nums) {
    List result = new ArrayList<>();
    for (int num : nums) {
        int size = result.size();
        for (int i = 0; i < size; i++) {
            List<Integer> subset = new ArrayList<>(result.get(i));
            subset.add(num);
            result.add(subset);
        }
    }
    result.add(new ArrayList<>());
    return result;
}

medium

A. The input array should be converted to a list first

B. The inner loop should run from size-1 to 0

C. The method should return an int, not a list

D. Empty subset is added at the end, should be added before loop

Solution

1. Step 1: Check when empty subset is added

   Empty subset must be added before starting to build subsets, so that initial subsets exist.

2. Step 2: Analyze code flow

   Here, empty subset is added after loops, so result.size() is zero initially and inner loop never runs, producing empty result except empty subset at end.

3. Final Answer:

   Empty subset is added at the end, should be added before loop -> Option D

4. Quick Check:

   Empty subset must be first for subsets to build [OK]

Hint: Add empty subset before loops to start building subsets [OK]

Common Mistakes:

• Adding empty subset after loops
• Incorrect loop ranges causing no subsets
• Returning wrong data type

5. Given an integer array nums that may contain duplicates, which modification to the standard subsets generation algorithm ensures the powerset contains no duplicate subsets?

hard

A. Only generate subsets of fixed size to avoid duplicates

B. Sort the array first and skip adding subsets that duplicate the last added subset

C. Generate subsets normally without changes; duplicates are automatically handled

D. Use a HashSet to store subsets and convert back to list at the end

Solution

1. Step 1: Understand duplicates in subsets

   Duplicates in input cause duplicate subsets if not handled.

2. Step 2: Use sorting and skip duplicates

   Sorting groups duplicates together. While generating subsets, skip adding subsets that duplicate the last added subset to avoid duplicates.

3. Final Answer:

   Sort the array first and skip adding subsets that duplicate the last added subset -> Option B

4. Quick Check:

   Sort + skip duplicates = unique subsets [OK]

Hint: Sort input and skip duplicates during subset generation [OK]

Common Mistakes:

• Ignoring duplicates causing repeated subsets
• Using HashSet but forgetting order or conversion
• Assuming duplicates don't affect subsets