arraylist 如何在子集算法中运行和重用

Question

I do not understand how ArrayList operate in this problem.

This is a algorithm for the question called "Subsets" from leetcode.

It basically outputs all the subsets of given array.

For example, if [1,2,3] is given array, then the output should be [[],[1],[2],[3],[1,2],[1,3],[2,3],[1,2,3]]

This is an algorithm for this question, but I do not understand how arraylist work in this code.

import java.util.*;

class Subsets {

  public static List<List<Integer>> findSubsets(int[] nums) {
    List<List<Integer>> subsets = new ArrayList<>();
    // start by adding the empty subset
    subsets.add(new ArrayList<>());
    for (int currentNumber : nums) {
      // we will take all existing subsets and insert the current number in them to create new subsets
      int n = subsets.size();
      for (int i = 0; i < n; i++) {
        // create a new subset from the existing subset and insert the current element to it
        List<Integer> set = new ArrayList<>(subsets.get(i));
        set.add(currentNumber);
        subsets.add(set);
      }
    }
    return subsets;
  }

  public static void main(String[] args) {
    List<List<Integer>> result = Subsets.findSubsets(new int[] { 1, 3 });
    System.out.println("Here is the list of subsets: " + result);

    result = Subsets.findSubsets(new int[] { 1, 2, 3 });
    System.out.println("Here is the list of subsets: " + result);
  }
}

The exact code part that I am stuck

        int n = subsets.size();
            for (int i = 0; i < n; i++) {
                List<Integer> set = new ArrayList<>(subsets.get(i));
                set.add(currentNumber);
                subsets.add(set);
            }
        }

Say n is 2 and currentNumber is 2 as well. In that literation, I think it just creates [2],[2] instead of [2],[1,2] since every inner loop iteration, it creates a new ArrayList and has a same value as currentNumber. I do not understand where [1,2] is from.

Can anyone explain how it outputs [2], [1,2] in second outer literation or where I do not understand?

Answer 1

To understand where the [1] comes from, we start with the first iteration:

subsets.add(new ArrayList<>()); adds the empty list to the set;

so, if currentNumber is 1 (and size of set is 1 too), it will add 1 to a copy of the empty list from the set ( get(0) ), resulting in [1] which is then added to the set.

Now we have the condition posted in question: the set is [[],[1]] , size 2 ( n = 2 ) and next number will be 2 ( currentNumber = 2 ).

---

subsets has two elements ( n == 2 ): the empty list, and a list containing just 1 (from previous iteration).

subsets = [[], [1]]

Now,

iteration i = 0 , is adding 2 to a copy of the empty list ( get(0) ) and adding the result ( [2]) to subsets ;

iteration i = 1 , is adding 2 to a copy of [1] ( get(1) ), result [1,2] is added to subsets .

subsets now is [],[1],[2],[1,2] - next iteration will add 3 to a copy of every one of that four lists and add the resulting 4 lists to subsets .

Key of that algorithm is new ArrayList<>(subsets.get(i)) which is creating a new list containing the elements of the list already in the set - a clone. Otherwise the end result would contain the same list repeated (with same content).