Question

我正在尝试将此循环转换为递归方法这个迭代版本有效:(递归尝试之后）

        public static int subCompareTwoCol(JobS j1, int index1, int index2, int indexTab1){ //Almost same method as above but with modifications when it encounters a 0.
        int indexData = 0;                                              
        int cost = j1.jobS[index1].length;                                       
        int nZeros = numberCounter(j1.jobS[index2], 0); 

        //index used under to not do the operations too many times.
        int tab1Index = 0;


        while(indexData<j1.jobS[index1].length){

            if(j1.jobS[index1][indexData] != 0){
                    assert(index2<6);
                    int j = numberCounter(j1.jobS[index1], j1.jobS[index1][indexData]);
                    int k = numberCounter(j1.jobS[index2], j1.jobS[index1][indexData]);

                        if(j <= k){
                            cost-=j;
                        }
                        if(j > k){
                            cost-=k;
                        }

                    indexData += j;

            }else{

                //Initialize 3 tabs, stocks them (previous column, actual column and next column).
                int[] tab1 = j1.jobS[indexTab1];
                int[] tab2 = j1.jobS[index1];
                int[] tab3 = j1.jobS[index2];

                //I want to convert this part !
                //For every numbers from the first tab (starts at the index so it doesnt count the same tool twice if multiple 0's).
                for(int i=tab1Index; i<Gui.toolN; i++){
                    tab1Index++;
                    if(isIn(tab3, tab1[i]) == true && isIn(tab2, tab1[i]) == false){ 
                        //Modifications to cost (and -=1 to nzeros because we "change" a 0 to the new tool).
                        nZeros-=1;
                        cost -=2;
                        tools.add(tab1[i]);

                        break;

                    }
                }
//This is what i think the code would look for replacing the for loop.
//                  int i=0;
//                  boolean b = false;
//                  assert(tab2[indexData]==0);
//                  recurs(j1, index1, index2, indexTab1, tab1, tab2, tab3, nZeros, cost, i, tab1Index, b);
//                  i=0;
                indexData++;
            }
        }

我尝试递归：

public static void recurs(JobS j1, int index1, int index2, int indexTab1, int[] tab1, int[] tab2, int[] tab3, int nZeros, int cost, int i, int tab1Index, boolean b){ //j1 is the input JobS, start b is false, start i with 0.

        i=Integer.valueOf(tab1Index);
        if(i<Gui.toolN){
            tab1Index++;


            if(isIn(tab3, tab1[i]) == true && isIn(tab2, tab1[i]) == false){ 
                //Modifications to cost (and -=1 to nzeros because we "change" a 0 to the new tool).
                nZeros-=1;
                cost -=2;
                tools.add(tab1[i]);

                return; 
            }else{
                i++;
                recurs(j1, index1, index2, indexTab1, tab1, tab2, tab3, nZeros, cost, i, tab1Index, b);
            }
            return; 

        }

我不知道出了什么问题。我试图从迭代版本复制所有功能，但我无法让它工作。我做错了什么？

Answer 1

基本问题

它们不会“回到旧状态” - 当您退出方法实例时，这些变量会被销毁（释放回内存堆）。

这些本地变量 - 在您输入方法时分配，在退出时释放;一些是输入参数，并从调用的参数接收它们的初始值。因此，他们不会“回到原来的状态”。您所看到的是前一个方法实例中未更改的状态。

每次调用例程时，都会向堆栈添加另一个实例。每个实例都有自己的变量版本，这些变量碰巧共享名称。他们不分享价值。

<强>解

通过遵循模块化编程的基本原则来解决这个问题：将值传递给带有参数列表的方法;您可以使用return列表返回值。例如，您的最终else子句可能如下所示：

child_result = recurs(j1, index1, index2, indexTab1,
                      tab1, tab2, tab3, nZeros,
                      cost, i, tab1Index, b);
tools.add(child_result);
return tools;

我没有读取您的代码以获取功能;您可能需要tools.add(child_result)之外的其他内容来积累正确的值。但是，我相信我已经告诉你了目前给你带来麻烦的基本原则。

Answer 2

问题来自指针，我用作参数的变量只是对方法保持改变，并在结束时回到原来的状态。我通过将变量设置为静态类变量来绕过这个，并在我想要的时候重置它们，但是Prune的解决方案看起来更好而且不那么混乱。

将for循环转换为递归方法java

2 个答案: