3

我陷入了将整数数组序列推送到数组列表的非常基本的方式中。我正在尝试为问题 K Combinations 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]

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

谢谢，萨拉特

4

3 回答 3

2 
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;
    }
}
于 2013-06-23T04:06:03.330 回答
1

你的错误是：combinations.add(arr);你总是在同一个数组上工作arr。

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

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

于 2013-06-23T04:15:36.660 回答
1

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

于 2013-06-23T04:27:37.027 回答