Question

我有一个相当令人困惑的问题。我正在为Android编程，我正在尝试获取一组整数的组合。我已经写出了生成组合的代码，我用远程调试器跟踪它，它似乎正常工作。它的工作原理是将每个新组合放在一个堆栈中。但是，堆栈中的每个组合都会随着活动数组的每次更改而更新，这些更改将以多种形式重复更改并提交到堆栈。我相信这个问题与我的新组合有关，包含指向原始数组的指针，而不是在创建组合时数组内容的副本。但是，我不知道如何解决这个问题。

感谢所有建议，感谢您的时间。

/**
 * 
 * @param comboSize
 *            The desired size of combo
 * @param values
 *            The dataset we are finding the values of; must be ints
 * @return an array containing all possible combos of comboSize for values
 */
private Combo[] getCombos(int comboSize, int[] values) {

    Stack<Combo> combos = new Stack<Combo>();
    // combos.ensureCapacity((int) Math.pow(values.length, comboSize) + 1);

    getIntArrayZeroToTarget(values.length - 1);

    int[] temp = getIntArrayZeroToTarget(comboSize-1);
    // System.arraycopy(surrogates, 0, temp, 0, comboSize);

    combos.push(new Combo(temp));

    // int workIndex = comboSize-1;

    //Evil things lurked in this code. Two days evaporated during mortal combat with it. I surrendered.

    switch (comboSize){
        case 2: for (int i = 0; i < values.length; i++){
            for (int j = i+1; j < values.length; j++){
                temp[0] = i;
                temp[1] = j;
                combos.push(new Combo(temp));
            }
        } break;
        case 3: for (int i = 0; i < values.length; i++){
            for (int j = i+1; j < values.length; j++){
                for (int k = j+1; k < values.length; k++){
                    temp[0] = i;
                    temp[1] = j;
                    temp[2] = k;
                    combos.push(new Combo(temp));
                }
            }
        } break;        
        case 4: for (int i = 0; i < values.length; i++){
            for (int j = i+1; j < values.length; j++){
                for (int k = j+1; k < values.length; k++){
                    for (int l = k+1; l < values.length; l++){
                        temp[0] = i;
                        temp[1] = j;
                        temp[2] = k;
                        temp[3] = l;
                        combos.push(new Combo(temp));                   
                    }
                }
            }
        } break;
    }

    //This code converts the psudoCombos (which contain the indices of the values) to combos that contain the actual values from the user
    Stack<Combo> cCombos = new Stack<Combo>();

    while (!combos.isEmpty()) {
        int[] temp1 = combos.pop().getContents();
        int[] temp2 = new int[temp1.length];

        for (int i = 0; i < temp1.length; i++)
            temp2[i] = values[temp1[i]];

        cCombos.push(new Combo(temp2));

    }

    Combo[] aCombos = new Combo[cCombos.size()];

    for (int i = 0; !cCombos.isEmpty(); i++){ //I spent about 7 hours debugging this code because I was missing the c in cCombos here...
        aCombos[i] = cCombos.pop();

    }
    String[] tempS = new String[aCombos.length];
    for (int i = 0; i < aCombos.length; i++){
        tempS[i] = aCombos[i].toString();
    }

    combosAsStrings = tempS;

    return aCombos;
}

Answer 1

你说你的问题来自引用相同数组的Combo对象是正确的。要解决此问题，只需在创建的每个Combo对象之前分配一个新数组。因此，在switch语句的每个内部for循环中，首先放置此行：

temp = new int[comboSize];

那应该可以解决你的问题。（或者，您可以使用Combo的默认构造函数，只需创建一个新数组并将给定的数组复制到新数组中。）

所以这是你的问题，但这里有一些建议：

首先：如果你只是引用switch语句的内部for循环中的values []数组，那么解决这个问题的“两阶段”方法可以合并为一个。例如，在第一个for循环中，在case 2下，将相关行替换为：

temp[0] = values[i];
temp[1] = values[j];

然后推送组合。这消除了从伪组合到真实组合的“第二次传递”的需要，并且消除了对第三个aCombos循环的需要，我假设你正在使用它来简单地回到组合的原始顺序（因为第二个循环循环反转它。）

第二：您可以使用递归函数消除对switch / case语句和重复代码的需要。这超出了问题的范围，但它也允许您支持任意数量值的组合，而不仅仅是您硬编码的数字（目前最多四个。）

堆栈的整数被设置为一个值

1 个答案: