Question

如果我有n个列表：

List<int> list1 = new List<int>
List<int> list2 = new List<int>
...
List<int> listn = new List<int>

每个元素包含不同数量的元素，例如

list1.add(1)
list1.add(2)
list2.add(3)
list2.add(4)
list2.add(5)
list3.add(6)
...
listn.add(100000)
listn.add(100001)

和一个列表列表

List<List<int>> biglist = new ArrayList<List<int>>
biglist.add(list1)
biglist.add(list2)
...
biglist.add(listn)

那么如何从包含元素的biglist生成permuationList，假设listn有m个元素：

[biglist.get(1).get(1),biglist.get(2).get(1), ..., biglist.get(n-1).get(1), biglist.get(n).get(1)]
[biglist.get(1).get(1),biglist.get(2).get(1), ..., biglist.get(n-1).get(1), biglist.get(n).get(2)]
...
[biglist.get(1).get(1),biglist.get(2).get(1), ..., biglist.get(n-1).get(1), biglist.get(n).get(m)]
[biglist.get(1).get(1),biglist.get(2).get(1), ..., biglist.get(n-1).get(2), biglist.get(n).get(1)]
....

谢谢！

Answer 1

有许多解决方案可以解决上述问题。这是其中之一。请看看。

public static void main(String args[]) throws Exception {
    List<Integer> list1 = new ArrayList<Integer>();
    List<Integer> list2 = new ArrayList<Integer>();
    list1.add(1);
    list1.add(2);
    list2.add(3);
    list2.add(4);
    List<List<Integer>> biglist = new ArrayList<List<Integer>>();
    biglist.add(list1);
    biglist.add(list2);
    print(biglist);
}

private static void print(List<List<Integer>> biglist) {
    List<Integer> list1 = biglist.get(0);
    List<Integer> list2 = biglist.get(1);
    for (Integer i : list1) {
        printCombination(i, list2);
    }
}

private static void printCombination(Integer i, List<Integer> list2) {
    for (Integer j : list2) {
        System.out.println("[" + i + ", " + j + "]");
    }
}

由于

Answer 2

您可以使用递归来实现此目的，将第一个列表与尾部列表（列表列表）合并。

public class Permutation   {
    public static List<List<Integer>> calculate(List<List<Integer>> input) {
        List<List<Integer>> result= new ArrayList<List<Integer>>();//

        if (input.isEmpty()) {  // If input is an empty list
            result.add(new ArrayList<Integer>());// then add empty list to the resultand return
            return result;
        } else {//here we have a non-empty list to process
            List<Integer> head = input.get(0);//get the first list as a head
            List<List<Integer>> tail= calculate(input.subList(1, input.size()));//recursion to calculate a tail list to calculate a tail list
            for (Integer h : head) {//we merge every head element with every tail list
                for (List<Integer> t : tail) {
                    List<Integer> resultElement= new ArrayList<Integer>();//here is a new element of our result list
                    resultElement.add(h);//firstly, add the head element to this tmp list
                    resultElement.addAll(t);//add all the element from the tail list
                    result.add(resultElement);
                }
            }
        }
        return result;
    }


    public static void main(String[] args) {
        List<List<Integer>> bigList=Arrays.asList(Arrays.asList(1,2),Arrays.asList(3,4),Arrays.asList(5,6));
        System.out.println(calculate(bigList));
    }
}

输出：

   [[1, 3, 5, 7], [1, 3, 5, 8], [1, 3, 6, 7], [1, 3, 6, 8], [1, 4, 5, 7], [1, 4, 5, 8], [1, 4, 6, 7], [1, 4, 6, 8], [2, 3, 5, 7], [2, 3, 5, 8], [2, 3, 6, 7], [2, 3, 6, 8], [2, 4, 5, 7], [2, 4, 5, 8], [2, 4, 6, 7], [2, 4, 6, 8]]

Answer 3

以下是从列表列表中生成所有元素组合的一般方法：

public static List<List<Integer>> generateCombinations(List<List<Integer>> lists) {
    final List<List<Integer>> result = new ArrayList<List<Integer>>();
    final List<Integer> accumulator = new ArrayList<Integer>();
    generateCombos(lists, result, accumulator, 0);
    return result;
}

// recursive helper method
private static void generateCombos(
        List<List<Integer>> input,
        List<List<Integer>> result,
        List<Integer> accumulator,
        int i)
{
    if (i < input.size()) {
        // add each element of the current list to the accumulator
        // and recurse with the next element of the input
        for (Integer elt : input.get(i)) {
            accumulator.add(i, elt);
            generateCombos(input, result, accumulator, i + 1);
            accumulator.remove(i);
        }
    } else {
        // add what's in the accumulator (as a new list, so we can reuse accumulator)
        result.add(new ArrayList<Integer>(accumulator));
    }
}

请注意，这会生成元素的所有组合 - 每个列表中的一个元素。从你的例子来看，我认为这就是你所追求的。如果您确实需要所有排列，则可以从此开始，然后生成结果中每个元素的所有重新排序（使用this thread中显示的方法）。

从列表<list <int>＆gt;中查找所有排列（笛卡尔积）在java </list <int>中

3 个答案: