Question

我陷入了将Integer-array序列推向arraylist的非常基本的方式。我正在尝试改变问题K Combinations of set of Integers的polygenelubricants的解决方案，以便不是打印它们，而是将它们推送到数组列表。

我的代码：

public class Test {

    static ArrayList<String> combinations;
    public static void main(String args[]) {
        Integer[] a3 = { 1, 2, 3, 4, 5 };
        comb(a3, 2);
    }
    public static void comb(Integer[] items, int k) {
        Arrays.sort(items);
        combinations = new ArrayList<String>();
        ArrayList<String> c1 = new ArrayList<String>();
        c1 = kcomb(items, 0, k, new Integer[k]);
        System.out.println("from comb");
        for (String x : c1) {
            System.out.println(x);
        }
    }
    public static ArrayList<String> kcomb(Integer[] items, int n, int k,
            Integer[] arr) {
        if (k == 0) {
            combinations.add(Arrays.toString(arr));
        } else {
            for (int i = n; i <= items.length - k; i++) {
                arr[arr.length - k] = items[i];
                kcomb(items, i + 1, k - 1, arr);
            }
        }
        return combinations;
    }
}

输出：

from comb
[1, 2]
[1, 3]
[1, 4]
[1, 5]
[2, 3]
[2, 4]
[2, 5]
[3, 4]
[3, 5]
[4, 5]

但是当我将ArrayList的类型从String更改为Integer []时，我得到了冗余输出。

更改了代码

public class Test {

    static ArrayList<Integer[]> combinations;
    public static void main(String args[]) {
        Integer[] a3 = { 1, 2, 3, 4, 5 };
        comb(a3, 2);
    }
    public static void comb(Integer[] items, int k) {
        Arrays.sort(items);
        combinations = new ArrayList<Integer[]>();
        ArrayList<Integer[]> c1 = new ArrayList<Integer[]>();
        c1 = kcomb(items, 0, k, new Integer[k]);
        System.out.println("from comb");
        for (Integer[] x : c1) {
            System.out.println(Arrays.toString(x));
        }
    }
    public static ArrayList<Integer[]> kcomb(Integer[] items, int n, int k,
            Integer[] arr) {
        if (k == 0) {
            combinations.add(arr);
        } else {
            for (int i = n; i <= items.length - k; i++) {
                arr[arr.length - k] = items[i];
                kcomb(items, i + 1, k - 1, arr);
            }
        }
        return combinations;
    }
}

输出：

from comb
[4, 5]
[4, 5]
[4, 5]
[4, 5]
[4, 5]
[4, 5]
[4, 5]
[4, 5]
[4, 5]
[4, 5]

有人可以帮助我指出我做错了什么......

谢谢，萨拉

Answer 1

public class Test {

    static ArrayList<Integer[]> combinations;
    public static void main(String args[]) {
        Integer[] a3 = { 1, 2, 3, 4, 5 };
        comb(a3, 2);
    }
    public static void comb(Integer[] items, int k) {
        Arrays.sort(items);
        combinations = new ArrayList<Integer[]>();
        ArrayList<Integer[]> c1 = new ArrayList<Integer[]>();
        c1 = kcomb(items, 0, k, new Integer[k]);
        System.out.println("from comb");
        for (Integer[] x : c1) {
            System.out.println(Arrays.toString(x));
        }
    }
    public static ArrayList<Integer[]> kcomb(Integer[] items, int n, int k,
            Integer[] arr) {
        if (k == 0) {
            combinations.add(arr);
        } else {
            for (int i = n; i <= items.length - k; i++) {
                Integer[] arr1 = new Integer[arr.length];
                System.arraycopy(arr, 0, arr1, 0, arr.length);
                arr1[arr.length - k] = items[i];
                kcomb(items, i + 1, k - 1, arr1);
            }
        }
        return combinations;
    }
}

Answer 2

您的错误：combinations.add(arr);您始终在同一个数组arr上工作。

请记住，数组是对象并具有引用。您将相同的数组arr引用保存到ArrayList，然后继续更改数组值。当你每次都在同一个数组上工作时，你总是得到所有其他组合的最后一个组合的值。

因此，在将其添加到ArrayList之前，需要克隆arr以获取新引用。由于字符串是不可变的，所以代码在之前工作，因为每个String都有自己的引用。

Answer 3

问题是你只创建一个Integer []数组 - 它被重用于每次调用kcomb，所以在进程结束时，同一个数组已多次添加到列表中，但是内容数组只是最后一个组合。此外，您不需要为此目的使用Integer [] - int []非常令人满意且效率更高。

将Integer数组推送到ArrayList

3 个答案: