在 Java 中的递归调用之间检索值

Question

我有一个递归代码，可以在每次调用时从集合中删除值。当它从调用返回到上一个递归时，我希望该集合被补充为与进入调用之前完全相同的状态。例如，在下面的代码中：

// initial value of this list is [a,b,c]  
void foo(ArrayList<Character> myList)     
{  
  for(int i=0; i< size;i++)
  {
    myList.remove(i); // Now it becomes [b,c]  
    foo(myList);  
    /* QUESTION: at this point how do i retrieve the value [b,c] -- because it goes into successive recursive calls I'm unable to get this value back!!*/  
  }  
}

Answer 1

在递归调用中将 myList 的副本传递给 foo：

// initial value of this list is [a,b,c]  
@SuppressWarnings("unchecked")
static void foo(ArrayList<Character> myList)     
{  
  for(int i=0; i< myList.size();i++)
  {
    myList.remove(i); // Now it becomes [b,c]  
    foo((ArrayList<Character>)myList.clone());
  }  
}

Answer 2

一般来说，你不需要。

要保留某些内容，您需要在递归调用之前复制它：

void foo(ArrayList<Character> myList)     
{  
  for(int i=0; i< size;i++)
  {
    myList.remove(i); // Now it becomes [b,c]  
    ArrayList<Character> lastList = new ArrayList<Character>(myList);
    foo(myList);  
    /* QUESTION: at this point how do i retrieve the value [b,c] -- because it goes into successive recursive calls I'm unable to get this value back!!*/
    // Answer: you now have a copy of the list prior to the recursive call in lastList  
  }  
}

Answer 3

这就是我递归地执行此操作的方式：

void foo(List<Character> list){
   if(list.size()>0){ //recursion condition
     list.remove(0);
     foo(list);
   }
}

但是您似乎有兴趣在任何递归之前访问原始列表。因此，您将被迫保持原始参数列表不变，并将其与包含原始输入的计算或处理进度的另一个列表一起传递给每个递归。

List<Character> foo(List<Character> source, List<Character> result){
  if(result == null){ // only on first call
     result = new ArrayList<Character>(source); //accumulator copy
  }

  //here you could do any comparisons you want
  
  if(!result.isEmpty()){ //recursion condition
    result.remove(0);
    return foo(source, result);
   }
   return result;
}

这就是我使用它的方式，

List<Character> letters = Arrays.asList('a', 'b', 'c');
List<Character> result = foo(letters, null);

如果我们遵循原始示例，我假设结果将始终是一个空列表。我只是在纸上完成了这一切，所以我没有在代码中对其进行测试。我希望这个想法足够清楚。