从 Java 中的列表创建不同的排列

Question

好的，

我需要一些帮助来弄清楚我该怎么做。

我有一个包含对象 1 - i 的子列表 A - n 的主列表，如下所示：

M{A(1, 2, 3, ... i),
B(1, 2, 3, ... i),
C(1, 2, 3, ... i), ... ,
n(1, 2, 3, ... i)}

我想要的是一个包含所有不同排列的列表，但我事先不知道子列表中有多少项，或者子列表中有多少对象。

所以对象 1 - 我在其中有一个我不想重叠的属性。我需要所有可能排列的列表。每个子列表中的一个对象。例如：

All{
1{A.1, B.1, C.1 N.1},
2{A.1, B.1, C.1 N.2},
3{A.1, B.1, C.1 N.3},
...
{A.1, B.1, C.1 N.i},
{A.1, B.1, C.2 N.1},
{A.1, B.1, C.2 N.2},
{A.1, B.1, C.2 N.3},
...
{A.1, B.1, C.2 N.i},
{A.1, B.2, C.1 N.1},
{A.1, B.2, C.1 N.2},
{A.1, B.2, C.1 N.3},
...
{A.1, B.2, C.1 N.i},
...
...
...
{A.i, B.i, C.i N.i}}

我一直在尝试在 Java 中想出一种递归的方法来做到这一点，但我不确定如何解决这个问题，因为我不知道任何列表的计数，而且它们可以每次更改为运行.

Answer 1

这是一个非常简单的迭代方法：将每个排列表示为数组 p，其中 K 个整数代表列表 A..n 中的索引。每个 K 元素 p[k] 的范围从零到 S[k]-1（含），其中 S[k] 是列表 k.

的长度

给定一个排列 p_i，你可以通过 "incrementing" 你的数组构造排列 p_i+1如果每个 p[k] 是一个 "digit":

，你将增加一个整数的方式

从全零排列开始
在每次迭代中，通过递增 p[0]
如果p[0]小于S[0]，则递增；继续下一个排列
否则，将p[0]设置为零，并递增p[1]
如果p[1]小于S[1]，则递增；继续下一个排列
否则，将p[1]设置为零，并递增p[2]
继续，直到到达最后一个索引 p[K-1]
如果将 p[K-1] 设置为零，则循环结束。

给定一个索引数组，构造实际列表元素的排列是微不足道的。请注意，排列的数量会很快变得非常大，因此在内存中存储它们时要非常小心。

Answer 2

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


public class Main
{
    private static String [][] inputList = 
    {
        {"A1","A2","A3","A4"},
        {"B1","B2","B3","B4"},
        {"C1","C2","C3","C4"},
    };
    private static int listSize = 4;
    private static List<List<String>> lists = new ArrayList<List<String>>();

    public static void permutation(List<Integer> indexes, int size)
    {
        if(checkEnd(indexes, size))
        {
            return;
        }
        List<String> nextList = new ArrayList<String>();
        int rowIndex = 0;
        for(int i : indexes)
        {
            nextList.add(inputList[rowIndex++][i]);
        }
        lists.add(nextList);
        permutation(nextIndexes(indexes, size),size);
    }

    public static boolean checkEnd(List<Integer> indexes, int size)
    {
        for(int i : indexes)
        {
            if(i < (size - 1))
            {
                return false;
            }
        }
        return true;
    }

    public static List<Integer> nextIndexes(List<Integer> indexes, int size)
    {
        Collections.reverse(indexes);
        for(int index = 0; index < indexes.size(); index++)
        {
            if(indexes.get(index) < (size - 1))
            {
                indexes.set(index, indexes.get(index) + 1);
                break;
            }
        } 
        Collections.reverse(indexes);
        return indexes;
    }

    public static void printList(List<String> list)
    {
        StringBuilder builder = new StringBuilder();
        builder.append("{");
        for(String field : list)
        {
            builder.append(field);
            builder.append(",");
        }
        builder.deleteCharAt(builder.length()-1);
        builder.append("}");
        System.out.println(builder.toString());
    }

    public static void main(String[] args)
    {
        List<Integer> indexes = new ArrayList<Integer>();
        for(int i = 0; i < inputList.length; i++)
        {
            indexes.add(0);
        }
        permutation(indexes, listSize);
        for(List<String> list : lists)
        {
            printList(list);
        }
    }
}

从 Java 中的列表创建不同的排列

Creating different permutations from lists in Java

java

recursion

list

permutation