二叉树中的回溯思想——Leetcode257/513/112/113

在二叉树中，和遍历结点相关的题其实都是更优先使用递归法的，因为递归法是与二叉树性质非常吻合的一种思想。其他的如迭代遍历法、层序遍历法模板化较强（过会儿再将模板进行总结），但是灵活性和便捷性就大打折扣了。

但初期，我对于递归还是不太熟练，具体表现在看代码觉得非常简单，自己一写就被绕进了逻辑的弯绕之中。每次写递归之前，要明确递归的三部曲：

1.明确递归函数的返回值和参数

2.明确终止条件

3.明确单层递归的逻辑

明确以上三部曲之后，递归就变得清晰许多了。

而递归中往往是隐藏着回溯思想的，废话先打住，从几个题中感受这种回溯的思想：

273.二叉树的所有路径

这题一看肯定会想到用dfs无脑做，确实思路也非常清晰，就是时间性能不佳

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res=new ArrayList<>();
        if(root==null)  return res;
        dfs(root,"",res);
        return res;
        
    }
    void dfs(TreeNode root,String path,List<String> res){
        if(root==null) return;
        //如果是叶子结点
        if(root.left==null&&root.right==null){
            res.add(path+root.val);
            return;
        }  
        //如果不是叶子结点，则继续访问其子结点
        dfs(root.left, path+root.val+"->",res);
        dfs(root.right,path+root.val+"->",res);
    }
}

但不妨可以试试回溯法，以避免每次寻找路径都是自顶向下查找

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        List<Integer> paths = new ArrayList<>();
        traversal(root, paths, res);
        return res;
    }
    private void traversal(TreeNode root, List<Integer> paths, List<String> res) {
        paths.add(root.val);
        // 叶子结点
        if (root.left == null && root.right == null) {
            // 输出
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < paths.size() - 1; i++) {
                sb.append(paths.get(i)).append("->");
            }
            sb.append(paths.get(paths.size() - 1));
            res.add(sb.toString());
            return;
        }
        if (root.left != null) {
            traversal(root.left, paths, res);
            paths.remove(paths.size() - 1);// 回溯
        }
        if (root.right != null) {
            traversal(root.right, paths, res);
            paths.remove(paths.size() - 1);// 回溯
        }
    }
}

此处有一个需要注意的细节，将临时List中结点取出并加上箭头的步骤中，应该使用StringBuffer/StringBuilder类而不是String类，当对字符串进行修改的时候，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。而在程序不要求线程安全（即一般情况下），优先使用StringBuilder型。

513.找树左下角值

这题用层序遍历来做是最好想到的，无脑套模板即可。但同样也是时间性能不如回溯法

class Solution {
    int maxlen=0;
    int leftvalue;
    public int findBottomLeftValue(TreeNode root) {
        leftvalue=root.val;
        findLeft(root,1);
        return leftvalue;
    }
    void findLeft(TreeNode root,int leftlen){
        if(root==null) return;
        if(root.left==null &&root.right==null){
            if(leftlen>maxlen){
                leftvalue=root.val;
                maxlen=leftlen;
            }
        }
        if(root.left!=null)
            findLeft(root.left,leftlen+1);
            
            /*此处即隐含着回溯思想，可理解为：
              leftlen=leftlen+1;
              findLeft(root.left,leftlen);
              leftlen=leftlen-1;
            */
        if(root.right!=null)
            findLeft(root.right,leftlen+1);
    }
}

关于递归函数什么时候要有返回值，什么时候不能有返回值的情况:

如果需要遍历整棵树，递归函数就不能有返回值。

如果需要遍历某一条固定路线，递归函数就一定要有返回值！

112.路径之和

 这题我想的是，使用回溯法遍历每条路径，将每条路径之和储存在Hashset中，最后判断其中是否存在targetSum。

class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if(root==null) return false;
        Set<Integer> s=new HashSet<>();
        findway(root,s,root.val);
        if(s.contains(targetSum))
            return true;
        else return false;

    }
    void findway(TreeNode root,Set s,int sum){
        if(root.left==null &&root.right==null)
            s.add(sum);
        if(root.left!=null)
            findway(root.left,s,sum+(root.left).val);//回溯思想的体现
        if(root.right!=null)
            findway(root.right,s,sum+(root.right).val);
    }
}

113.路径总和 II

 此题思路和上题是类似的

class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int targetsum) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) return res; // 非空判断
        
        List<Integer> path = new ArrayList<>();
        findway(root, targetsum, res, path);
        return res;
    }
    public void findway(TreeNode root, int targetsum, List<List<Integer>> res, List<Integer> path) {
        path.add(root.val);
        
        // 遇到了叶子节点时
        if (root.left == null && root.right == null) {
            // targetsum 每次减去根节点的值，以避免进行判断
            if (targetsum - root.val == 0) {
                res.add(new ArrayList<>(path));//此处需重点注意
            }
            return; // 如果和不为 targetsum，返回
        }
        if (root.left != null) {
            findway(root.left, targetsum - root.val, res, path);
            path.remove(path.size() - 1); // 回溯
        }
        if (root.right != null) {
            findway(root.right, targetsum - root.val, res, path);
            path.remove(path.size() - 1); // 回溯
        }
    }
}

但此处有个隐藏的坑困扰了我很久，就是res.add(new ArrayList<>(path))这行，我起初一直用的是res.add(path)，始终无法通过全部样例。其原因是：

1.res.add(list)是浅拷贝，将res尾部指向了path地址，后续path的内容变化会导致放入res中的元素发生变化。

2.res.add(new ArrayList<>()) 是深拷贝，开辟一个独立地址，地址中存放的内容为path这一list链表，后续path的变化不会影响到res。

小结：

回溯主要是一种思想，往往隐藏在递归之中，主要还是要捋清递归的三部曲以及其逻辑，这样才不会陷入思路混乱。

参考资料：代码随想录

res.add(new ArrayList＜＞(path))和res.add(path)的区别_Edmundshi的博客-CSDN博客