ArrayLists笛卡尔积元素的正确顺序

Question

I tried to generate Cartesian product of unknown number of ArrayLists (of fixed type) based on this answer: Cartesian product of an arbitrary number of sets . But I have found something strange. The cartesian products is always given in reverse order. For example, if A and B are two Lists, B's elements are given first and A's elements are given second in cartesian pair. What could be possible reason? How to fix that? Original answerer says, ordering does not matter in Cartesian product. But I think ordering is the main thing while making cartesian products especially when each set represents coordinates of plane.

Modified Code:

private static Set<ArrayList<Double>> cartesianProduct(ArrayList<ArrayList<Double>> sets) {
    if (sets.size() < 2)
        throw new IllegalArgumentException(
                "Can't have a product of fewer than two sets (got " +
                        sets.size() + ")");

    return _cartesianProduct(0, sets);
}

private static Set<ArrayList<Double>> _cartesianProduct(int index, ArrayList<ArrayList<Double>> sets) {
    Set<ArrayList<Double>> ret = new HashSet<>();
    if (index == sets.size()) {
        ret.add(new ArrayList<>());
    } else {
        for (Double obj : sets.get(index)) {
            for (ArrayList<Double> set : _cartesianProduct(index + 1, sets)) {
                set.add(obj);
                ret.add(set);
            }
        }
    }
    return ret;
}

Output:

ArrayList<Double> l1 = new ArrayList<>(Arrays.asList(1.0, 2.0));
ArrayList<Double> l2 = new ArrayList<>(Arrays.asList(4.0, 5.0));
ArrayList<ArrayList<Double>> l = new ArrayList<>(Arrays.asList(l1, l2));
Set<ArrayList<Double>> a = cartesianProduct(l);

// a = [[4.0, 1.0], [4.0, 2.0], [5.0, 1.0], [5.0, 2.0]]

Answer 1

This happens because of recursion. Index is initially 0, so at the line for (ArrayList<Double> set: _cartesianProduct(index + 1, sets)) { , your code calls cartesianProduct again with index=1. Again it reaches that line, and calls cartesianProduct with index=2. When it is at index=2, it reaches its base case and returns a set with an empty ArrayList .

Then it goes back to the stackframe where index=1 (remember, obj is 4.0 because sets.get(1) is the ArrayList containing 4 and 6). It adds all the doubles in sets.get(index) (here it is 4.0 and 6.0) to their own ArrayLists in ret . Then it reaches the end of the foreach loop and returns the set, which now has 2 ArrayLists, one containing a 4.0 and the other 6.0.

The same happens at index=0, so the first list(or set)'s elements are added after the second list's elements. That's why you get reverse results.

To fix this, you could decrement index every time, going from sets.size() to 0 instead of the other way around. To reverse it, you can also simply call Collections.reverse() on every set inside the result.

//Fix by decrementing index
private static Set<ArrayList<Double>> cartesianProduct(ArrayList<ArrayList<Double>> sets) {
    if (sets.size() < 2)
        throw new IllegalArgumentException(
                "Can't have a product of fewer than two sets (got " + sets.size() + ")");
    //Be sure to start at the end of 'sets' so you can go down by one
    return cartesianProduct(sets.size() - 1, sets);
}

private static Set<ArrayList<Double>> cartesianProduct(int index, ArrayList<ArrayList<Double>> sets) {
    Set<ArrayList<Double>> ret = new HashSet<>();
    //Counting to 0 instead of to the end of the sets ArrayList
    if (index < 0) {
        ret.add(new ArrayList<>());
    } else {
        for (Double obj : sets.get(index)) {
            for (ArrayList<Double> set : cartesianProduct(index - 1, sets)) {
                set.add(obj);
                ret.add(set);
            }
        }
    }
    return ret;
}

//Alternative answer using Collections.reverse
private static Set<ArrayList<Double>> cartesianProduct(ArrayList<ArrayList<Double>> sets) {
    if (sets.size() < 2)
        throw new IllegalArgumentException(
                "Can't have a product of fewer than two sets (got " + sets.size() + ")");
    //This basically goes through the set of sets and reverses each ArrayList
    return cartesianProduct(0, sets).stream().map(Collections::reverse).collect(Collectors.toSet());
}

Answer 2

This method constructs the cartesian product in reverse because it creates the product "inside out" - when it's returning out of the recursion.

Printed out the value returned by each level in the recursion and you'll see how it happens.

The second level of recursion works on list B and returns [[4], [5]].

The first level of recursion takes [[4], [5]] and uses the list.add method to add items from the list A. This method adds items to the end of the list so the result is [[4, 1], [5, 1], [4, 2], [5, 2]].

How to fix it?

A quick fix is inserting items to the front, instead of to the back. Instead of set.add(obj) use:

set.add(0, obj);

Another option is to reverse the order of iteration so that the second level of recursion uses list A, and the first level uses list B. The initial call to start the recursion would be made from sets.size() and it should count down instead of up:

    return _cartesianProduct(sets.size() - 1, sets);
...
            for (ArrayList<Double> set : _cartesianProduct(index - 1, sets)) {

Yet another option is changing the recursion so that the product is built on the way down the recursion - "outside in" - instead of on the way out. This is the approach taken in another answer to the question you link to: https://stackoverflow.com/a/9496234/318758

Answer 3

If order matters, you can rewrite your code as follows:

ArrayList<Double> l1 = new ArrayList<>(Arrays.asList(1.0, 2.0, 3.0));
ArrayList<Double> l2 = new ArrayList<>(Arrays.asList(4.0, 5.0, 6.0));

List<List<Double>> cartesianProduct = Stream.of(l1, l2)
        // represent each list element as a singleton list
        .map(list -> list.stream().map(Collections::singletonList)
                // List<List<Double>>
                .collect(Collectors.toList()))
        // intermediate output
        //[[1.0], [2.0], [3.0]]
        //[[4.0], [5.0], [6.0]]
        .peek(System.out::println)
        // summation of pairs of inner lists
        .reduce((list1, list2) -> list1.stream()
                // combinations of inner lists
                .flatMap(inner1 -> list2.stream()
                        // merge two inner lists into one
                        .map(inner2 -> Stream.of(inner1, inner2)
                                .flatMap(List::stream)
                                .collect(Collectors.toList())))
                // list of combinations
                .collect(Collectors.toList()))
        // returns List<List<Double>>, otherwise an empty list
        .orElse(Collections.emptyList());

// final output
cartesianProduct.forEach(System.out::println);
//[1.0, 4.0]
//[1.0, 5.0]
//[1.0, 6.0]
//[2.0, 4.0]
//[2.0, 5.0]
//[2.0, 6.0]
//[3.0, 4.0]
//[3.0, 5.0]
//[3.0, 6.0]

---

^{See also: Cartesian product of an arbitrary number of sets}