从数组(Java)获取大小为n的所有组合的算法?

现在我正在尝试编写一个接受数组和整数n的函数,并给出了每个大小n组合的列表(因此是一个int数组的列表).我可以使用n个嵌套循环编写它,但这只适用于特定大小的子集.我无法弄清楚如何将它推广到任何大小的组合中.我想我需要使用递归?

这是3个元素的所有组合的代码,我需要一个任意数量元素的算法.

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

public class combinatorics{
    public static void main(String[] args) {

        List<int[]> list = new ArrayList<int[]>();
        int[] arr = {1,2,3,4,5};
        combinations3(arr,list);
        listToString(list);
    }

    static void combinations3(int[] arr, List<int[]> list){
        for(int i = 0; i<arr.length-2; i++)
            for(int j = i+1; j<arr.length-1; j++)
                for(int k = j+1; k<arr.length; k++)
                    list.add(new int[]{arr[i],arr[j],arr[k]});
    }

    private static void listToString(List<int[]> list){
        for(int i = 0; i<list.size(); i++){ //iterate through list
            for(int j : list.get(i)){ //iterate through array
                System.out.printf("%d ",j);
            }
        System.out.print("\n");
        }
    }
}
最佳答案
这是一个经过深入研究的产生所有k子集的问题,即k-combinations,这可以轻松完成而不需要递归.

这个想法是使数组k的数组从输入数组(从0到n-1的数字)按顺序保持元素的索引序列. (然后可以通过从初始数组获取这些索引的项目来创建子集).因此,我们需要生成所有这样的索引序列.

第一个索引序列将为[0,1,2,…,k-1],在第二个步骤中,它将切换到[0,1,2,…,k],然后切换到[0,1,2 ,… k 1]等等.最后一个可能的序列将是[n-k-1,n-k-2,…,n-1].

在每个步骤中,算法查找最接近可以递增的最终项目,将其递增并填充该项目的项目.

为了说明,考虑n = 7和k = 3.首先索引序列是[0,1,2],然后[0,1,3]等等.在某些时候,我们有[0,5,6] :

[0, 5, 6] <-- scan from the end: "6" cannot be incremented, "5" also, but "0" can be
[1, ?, ?] <-- "0" -> "1"
[1, 2, 3] <-- fill up remaining elements

next iteration:

[1, 2, 3] <-- "3" can be incremented
[1, 2, 4] <-- "3" -> "4"

因此,[0,5,6]之后是[1,2,3],然后进入[1,2,4]等.

码:

int[] input = {10, 20, 30, 40, 50};    // input array
int k = 3;                             // sequence length   

List<int[]> subsets = new ArrayList<>();

int[] s = new int[k];                  // here we'll keep indices 
                                       // pointing to elements in input array

if (k <= input.length) {
    // first index sequence: 0, 1, 2, ...
    for (int i = 0; (s[i] = i) < k - 1; i++);  
    subsets.add(getSubset(input, s));
    for(;;) {
        int i;
        // find position of item that can be incremented
        for (i = k - 1; i >= 0 && s[i] == input.length - k + i; i--); 
        if (i < 0) {
            break;
        }
        s[i]++;                    // increment this item
        for (++i; i < k; i++) {    // fill up remaining items
            s[i] = s[i - 1] + 1; 
        }
        subsets.add(getSubset(input, s));
    }
}

// generate actual subset by index sequence
int[] getSubset(int[] input, int[] subset) {
    int[] result = new int[subset.length]; 
    for (int i = 0; i < subset.length; i++) 
        result[i] = input[subset[i]];
    return result;
}

转载注明原文:从数组(Java)获取大小为n的所有组合的算法? - 代码日志