Java 两个给定集合的打印置换

给定的是一个带有一些元素的集合

M

，例如

M={a，b}

，以及另一个集合

F

，其特定数字表示

M

排列中的数量。e、 g.

F={3，1}

，因此在本例中，排列为：

P={（a，a，a，b，a），（a，b，a，a），（b，a，a）}

我想打印它们，但在处理递归之后，我仍然无法让它工作。 我当前的代码如下：

void printPermutations(Map<Integer, String> m, List<Integer> f, List<Integer> cf, int size, int depth, int index, int innerindex, List<String> toPrint)
{
    if(depth == size)
    {
        System.out.println("");
        for(String a : toPrint)
            System.out.print(a + " ");
        System.out.println("");
    }
    else
    {
        for(int i = index + 1; i < m.size(); ++i)
        {   
            if(f.get(innerindex).compareTo(Integer.valueOf(1)) < 0)
                ++innerindex;

            toPrint.add(m.get(innerindex));

            f.set(innerindex, f.get(innerindex) - Integer.valueOf(1));
            printPermutations(m, f, f, size, depth + 1, i, innerindex, toPrint);
            f.set(innerindex, f.get(innerindex) + Integer.valueOf(1));

            toPrint.remove(m.get(innerindex));

            if(f.get(innerindex).compareTo(cf.get(innerindex)) == 0 && innerindex > 0)
                --innerindex;
        }
    }
}

//call
//asume some cool elements in f and mAsSet
//    f.size() == mAsSet.size()

List<String> toPrint = new ArrayList<String>();
Map<Integer, String> m = new HashMap<Integer, String>(mAsSet.size());
int counter = 0;
for(String a : m)
    m.put(Integer.valueOf(counter++), a);
int size = 0;
for(Integer i : f)
    size += i;
printPermutations(m, f, f, size, 0, -1, 0, toPrint);

无效打印置换（映射m、列表f、列表cf、整数大小、整数深度、整数索引、整数内部索引、列表TopPrint）
{
如果（深度==大小）
{
System.out.println（“”）；
for（字符串a:toPrint）
系统输出打印（a+“”）；
System.out.println（“”）；
}
其他的
{
对于（int i=index+1；i0）
--内部索引；
}
}
}
//召唤
//在f和mAsSet中使用一些很酷的元素
//f.size（）==mAsSet.size（）
List toPrint=new ArrayList（）；
Map m=新的HashMap（mAsSet.size（））；
int计数器=0；
for（字符串a:m）
m、 put（整型.valueOf（计数器++），a）；
int size=0；
for（整数i:f）
尺寸+=i；
打印置换（m，f，f，大小，0，-1，0，TopPrint）；

我真的看不出有什么问题，它什么也没印出来。当然，我调试了这个，但我真的没有任何其他想法来归档我想要的东西。

看一下。如果您正在处理的代码可以包含第三方库，而不是使用。这将产生如下结果：

final ImmutableList<String> m = ImmutableList.of("a", "b");
final ImmutableList<Integer> f = ImmutableList.of(3, 1);

final ImmutableList<String> values = FluentIterable.from(m).
  transformAndConcat(new Function<String, Iterable<String>>() {

    int c = 0;

    public Iterable<String> apply(String input) {
        return Collections.nCopies(f.get(c++), input);
    }
}).toList();

final ImmutableSet<List<String>> permutations = ImmutableSet.copyOf(Collections2.permutations(values));
System.out.println(Joiner.on("\n").join(permutations));

final ImmutableList m=不可变列表，共有（“a”、“b”）；
最终不可变列表f=不可变列表（3，1）；
最终的ImmutableList值=FluentIterable.from（m）。
transformAndConcat（新函数（）{
int c=0；
公共Iterable应用（字符串输入）{
返回Collections.nCopies（f.get（c++），输入）；
}
}).toList（）；
最终ImmutableSet置换=ImmutableSet.copyOf（集合2.permutations（值））；
System.out.println（Joiner.on（“\n”）.join（置换））；

---

Collections2.permutations将生成重复的输出（即，[a，a，a，b]将多次出现，但由于permutation是作为迭代器实现的，因此不会使用额外的内存，因为生成的ImmutableSet只包含单个值。迭代运行值！（阶乘）多次。

为什么要将您的工作代码更改为伪代码？添加可执行代码，以便人们可以随意处理。@Jeroenvanevel:对不起，我只是不想让任何关于我的Java内容的离题内容。也许这个主题可以帮到您。您需要将逻辑应用到您的需要。@RamiStefanidis我已经读过了。我的意思是，当然是我我可以把所有排列列成一个大的列表，然后删除那些加倍的排列，但这不是你想要的性能，不是吗？这正是我想要的。没有加倍的

（a，a，b）

集合2。排列将输出（a，a，a，b）多次，但ImmutableSet.copyOf可防止在置换集中发生这种情况。