Java 何时需要回溯？

例如，关于二叉树的以下两个问题，为什么第一个需要回溯（每次碰到叶节点时都删除工作集中的最后一个元素），而另一个不需要？他们都要求所有的路径都满足要求，而不是试图找出路径是否存在，因为当碰到一片叶子时，路径已经到达终点，为了格式化其他可能的路径，我们不应该返回到我们访问的最后一个节点吗

第一个问题的答复：

 public List<List<Integer>> pathSum(TreeNode root, int sum) {
     List<List<Integer>> finalResult=new ArrayList<List<Integer>>();
     List<Integer> tempResult = new ArrayList<Integer>();
     pathSumHelper(root,sum,tempResult,finalResult);
     return finalResult;
 }
 public void pathSumHelper(TreeNode node, int sum, List <Integer> tempResult, List<List<Integer>> finalResult){
     if(node == null) return;
     sum -= node.val;
     if( node.left == null && node.right == null ){  
        if( sum == 0){
          tempResult.add(node.val);
          finalResult.add(new ArrayList<Integer>(tempResult));
          tempResult.remove(tempResult.size() -1);
        }
     return;
     }
     tempResult.add(node.val);
     pathSumHelper(node.left, sum, tempResult, finalResult);
     pathSumHelper(node.right, sum, tempResult, finalResult);
     tempResult.remove(tempResult.size() -1 );
 }

 public List<String> binaryTreePaths(TreeNode root) {
    List<String> finalResult = new ArrayList<String>();
    String tempResult = "";
    findPath(root, tempResult, finalResult);
    return finalResult;
 }

 public void findPath(TreeNode node, String tempResult, List<String> finalResult){
    if( node == null ){
        return;
    }
    if(node.left == null && node.right == null){
        tempResult += String.valueOf(node.val);        
        finalResult.add(tempResult);
        // why no delete last integer added in tempResult before return?
        return;
    }
    tempResult += String.valueOf(node.val);
    findPath(node.left, tempResult+"->", finalResult);
    findPath(node.right, tempResult+"->", finalResult);
    // same, why no delete last integer added in tempResult before return?               
 }

公共列表路径和（树节点根，整数和）{
List finalResult=new ArrayList（）；
List tempResult=new ArrayList（）；
pathSumHelper（root、sum、tempResult、finalResult）；
返回最终结果；
}
public void pathSumHelper（TreeNode节点、int和、List tempResult、List finalResult）{
if（node==null）返回；
sum-=node.val；
如果（node.left==null&&node.right==null）{
如果（总和=0）{
tempResult.add（node.val）；
添加（新的ArrayList（tempResult））；
tempResult.remove（tempResult.size（）-1）；
}
返回；
}
tempResult.add（node.val）；
pathSumHelper（node.left、sum、tempResult、finalResult）；
pathSumHelper（node.right、sum、tempResult、finalResult）；
tempResult.remove（tempResult.size（）-1）；
}

第二个问题的答复：

 public List<List<Integer>> pathSum(TreeNode root, int sum) {
     List<List<Integer>> finalResult=new ArrayList<List<Integer>>();
     List<Integer> tempResult = new ArrayList<Integer>();
     pathSumHelper(root,sum,tempResult,finalResult);
     return finalResult;
 }
 public void pathSumHelper(TreeNode node, int sum, List <Integer> tempResult, List<List<Integer>> finalResult){
     if(node == null) return;
     sum -= node.val;
     if( node.left == null && node.right == null ){  
        if( sum == 0){
          tempResult.add(node.val);
          finalResult.add(new ArrayList<Integer>(tempResult));
          tempResult.remove(tempResult.size() -1);
        }
     return;
     }
     tempResult.add(node.val);
     pathSumHelper(node.left, sum, tempResult, finalResult);
     pathSumHelper(node.right, sum, tempResult, finalResult);
     tempResult.remove(tempResult.size() -1 );
 }

 public List<String> binaryTreePaths(TreeNode root) {
    List<String> finalResult = new ArrayList<String>();
    String tempResult = "";
    findPath(root, tempResult, finalResult);
    return finalResult;
 }

 public void findPath(TreeNode node, String tempResult, List<String> finalResult){
    if( node == null ){
        return;
    }
    if(node.left == null && node.right == null){
        tempResult += String.valueOf(node.val);        
        finalResult.add(tempResult);
        // why no delete last integer added in tempResult before return?
        return;
    }
    tempResult += String.valueOf(node.val);
    findPath(node.left, tempResult+"->", finalResult);
    findPath(node.right, tempResult+"->", finalResult);
    // same, why no delete last integer added in tempResult before return?               
 }

公共列表二进制树路径（树节点根）{
List finalResult=new ArrayList（）；
字符串tempResult=“”；
findPath（root、tempResult、finalResult）；
返回最终结果；
}
公共void findPath（树节点、字符串tempResult、列表finalResult）{
if（node==null）{
返回；
}
if（node.left==null&&node.right==null）{
tempResult+=String.valueOf（node.val）；
最终结果添加（临时结果）；
//为什么在返回之前不删除tempResult中添加的最后一个整数？
返回；
}
tempResult+=String.valueOf（node.val）；
findPath（node.left，tempResult+“->”，finalResult）；
findPath（node.right，tempResult+“->”，finalResult）；
//同样，为什么在返回之前不删除tempResult中添加的最后一个整数？
}

在第二种算法中，当递归调用

findPath

时，使用+运算符，同时将

tempResult

+“->”作为参数传递+运算符导致连接，从而创建一个新的

字符串
对象。基本上，在递归的每个级别上，您都将一个新的
字符串
对象传递给较低级别，并将每个级别的
tempResult
变量保留在较低级别无法访问的地方

因此，您实际上无权访问上层递归的
String
对象，即使您回溯，它也只会更新传递到该递归级别的
String
对象，而不会更新属于上层的
tempResult
，这是从来没有机会开始的！这就是为什么在第二个解决方案中不需要回溯，因此也没有回溯。
根据我对您问题的回答，我认为您还应该在这个问题中添加java作为标记，因为您提出的问题与您使用的语言和编程非常相关。我会自己添加，但我必须删除您添加的其中一个标签。如果你能从中选择一个，那就更好了。嗨，伊琳，这是一个很好的答案，谢谢！