java中数组的所有可能组合和子集

给定一个可变维度的数组。。。。 例如数组={1,2,4,5}

我需要一种方法来泛化数组中所有可能的组合和子集

给定一个n个元素的数组，我需要所有子集（1个元素的所有子集，2个元素的所有子集，n个元素的所有子集），每个子集都有一个所有可能的置换

例如，结果应为：

{1}
{2}
{4}
{5}
{1,2}
{1,4}
{1,5}
{2,1}
{2,4}
{2,5}
....
....
{1,2,4,5}
{1,2,5,4}
{1,4,2,5}
{1,5,2,4}
{1,5,4,2}
{2,1,4,5}
{2,1,5,4}
....
....
{5,1,4,2}
{5,1,2,4}
{5,2,4,1}
....
....
etc...

所有的组合

有捷径吗？

---

我不知道……

首先，您需要找到数组的所有子集，这些子集是2^n集（包括空集）。找到子集后，循环遍历每个子集，并使用一个简单的递归计算它的排列，你可以在网上轻松找到。

我知道的最简单的方法是将

I

从

1

循环到

2^n-1

，其中n是数组的大小

i

位模式中的1告诉您要选择哪些元素

e、 g:在第10个循环上使用数组

[4,28,37,135]

：

10 == 1010b

1,0,1,0告诉您选择数组的第一个和第三个元素：

[4,37]

既然数组中有了所有元素的组合，就需要得到所有排列，这可以通过一些简单的递归来完成

伪代码：

function getPermutations(arr)
{
    if length of arr == 1 {
        return [arr]
    } else {
        for i = 0 to highest index of arr {
            sub_arr = copy of arr
            remove element i from sub_arr
            perms = getPermutations(sub_arr)

            for each perm in perms {
                insert arr[i] at beginning of perm
            }
            return perms 
        }
    }
}

---

您应该应用两个步骤：

您需要找到给定输入的所有子集。这组子集称为

对于该幂集的每个元素（即每个子集），您都需要所有元素

此实现使用项目中的一些实用程序类。输出还包含空集

{}

，并且不按大小排序，但这可以作为后处理步骤轻松完成

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;

public class AllCombinations {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,4,5);

        PowerSetIterable<Integer> powerSet = 
            new PowerSetIterable<Integer>(list);
        for (List<Integer> subset : powerSet)
        {
            PermutationIterable<Integer> permutations = 
                new PermutationIterable<Integer>(subset);
            for (List<Integer> permutation : permutations) {
                System.out.println(permutation);
            }
        }

    }
}

//From https://github.com/javagl/Combinatorics
class PowerSetIterable<T> implements Iterable<List<T>> {
    private final List<T> input;
    private final int numElements;
    public PowerSetIterable(List<T> input) {
        this.input = input;
        numElements = 1 << input.size();
    }

    @Override
    public Iterator<List<T>> iterator() {
        return new Iterator<List<T>>() {
            private int current = 0;

            @Override
            public boolean hasNext() {
                return current < numElements;
            }

            @Override
            public List<T> next() {
                if (!hasNext()) {
                    throw new NoSuchElementException("No more elements");
                }
                List<T> element = new ArrayList<T>();
                for (int i = 0; i < input.size(); i++) {
                    long b = 1 << i;
                    if ((current & b) != 0) {
                        element.add(input.get(i));
                    }
                }
                current++;
                return element;
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException(
                        "May not remove elements from a power set");
            }
        };
    }
}
//From https://github.com/javagl/Combinatorics
class PermutationIterable<T> implements Iterable<List<T>> {
    public static int factorial(int n) {
        int f = 1;
        for (int i = 2; i <= n; i++) {
            f = f * i;
        }
        return f;
    }
    private final List<T> input;
    private final int numPermutations;
    public PermutationIterable(List<T> input) {
        this.input = input;
        numPermutations = factorial(input.size());
    }

    @Override
    public Iterator<List<T>> iterator() {
        if (input.size() == 0) {
            return Collections.<List<T>> singletonList(
                    Collections.<T> emptyList()).iterator();
        }
        return new Iterator<List<T>>() {
            private int current = 0;

            @Override
            public boolean hasNext() {
                return current < numPermutations;
            }

            @Override
            public List<T> next() {
                if (!hasNext()) {
                    throw new NoSuchElementException("No more elements");
                }
                // Adapted from http://en.wikipedia.org/wiki/Permutation
                List<T> result = new ArrayList<T>(input);
                int factorial = numPermutations / input.size();
                for (int i = 0; i < result.size() - 1; i++) {
                    int tempIndex = (current / factorial) % (result.size() - i);
                    T temp = result.get(i + tempIndex);
                    for (int j = i + tempIndex; j > i; j--) {
                        result.set(j, result.get(j - 1));
                    }
                    result.set(i, temp);
                    factorial /= (result.size() - (i + 1));
                }
                current++;
                return result;
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException(
                        "May not remove elements from a permutation");
            }
        };
    }
}

import java.util.ArrayList；
导入java.util.array；
导入java.util.Collections；
导入java.util.Iterator；
导入java.util.List；
导入java.util.NoSuchElementException；
公共类所有组合{
公共静态void main（字符串[]args）{
List=Arrays.asList（1,2,4,5）；
功率可设定功率集=
新的PowerSetable（列表）；
用于（列表子集：功率集）
{
置换可置换=
新的可置换（子集）；
for（列表置换：置换）{
System.out.println（置换）；
}
}
}
}
//从https://github.com/javagl/Combinatorics
类powerseterable实现了Iterable{
私人最终清单输入；
私人最终积分；
公用PowerSetable（列表输入）{
这个输入=输入；
numElements=1我提供了我想到的第一个解决方案，用于查找给定列表的所有子集（不是排列，只有子集）方法subSets给出特定大小的所有子集，而allSubSets迭代大小。一旦有了所有子集的列表，就可以实现一个在该列表上迭代的置换函数

public class Subsets<T> {
    public List<List<T>> allSubSets(List<T> list) {
        List<List<T>> out = new ArrayList<List<T>>();
        for(int i=1; i<=list.size(); i++) {
            List<List<T>> outAux = this.subSets(list, i);
            out.addAll(outAux);
        }
        return out;
    }

    private List<List<T>> subSets(List<T> list, int size) {
        List<List<T>> out = new ArrayList<List<T>>();
        for(int i=0; i<list.size()-size+1;i++) {
            List<T> subset = new ArrayList<T>();
            for (int j=i;j<i+size-1;j++) {
                subset.add(list.get(j));
            }
            if (!(size==1 && i>0)) {
                for (int j=i+size-1;j<list.size();j++) {
                    List<T> newsubset = new ArrayList<T>(subset);
                    newsubset.add(list.get(j));
                    out.add(newsubset);
                }
            }
        }
        return out;
    }
}

公共类子集{
公共列表所有子集（列表）{
List out=new ArrayList（）；
对于（int i=1；我你尝试过什么，以及你尝试过的时候发生了什么？或者，如果你没有写任何代码，试着写下说明：例如，排列和子集是什么意思？检查这个我没有任何代码…因为我真的很困惑。图西塔的例子生成所有排列。我需要所有的组合。它的意思是：giv在一个数组中，我需要所有子集（1个元素的所有子集，2个元素的所有子集，n个元素的所有子集）每个子集的一个所有可能的置换。@assylias的可能重复就是这样，结合查找这些集合中的每个置换。
Subsets<Integer> aux = new Subsets<Integer>();
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
List<List<Integer>> out = aux.allSubSets(list);
System.out.println(out);