两个平台的markdown指令不兼容，所以想看更整洁和清晰的内容请移步知乎
基础：形参与实参
实参是程序中已经分配了内存空间的参数，它可以被赋予一个具体的值，比如常数、数组、地址（指针），对象，
形参则是你在写一个被调函数时，为了说明用到的自变量的类型、要进行什么操作而定义的，在调用函数前它不会被分配内存空间，更不会被赋予具体的值。
调用函数时，形参会被分配一个新的内存空间，实参的值就会被“复制”进去，让它在被调函数中参与运算。而实参本身不参与这个运算，它仅仅起到一个传递值的作用（不过在C++中可以用&改变实参的值）。如果参数的形式是指针，那么“复制”的就是地址。
1 题目一：【leetcode 112】
给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。
叶子节点 是指没有子节点的节点。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/path-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
1.1 总结(重点)
总的来说，从1.2 的代码可以看出，这里的sum是作为入口参数的，因为int本身是个实参，属于值传递，所以用到递归时不需要回溯（因为对于sum的每一种状态，递归栈中都有保存），
但是从1.3的代码知道，这时的sum是相当于一个全局变量，所以无论递归到哪一层，全局变量始终只记录最新的值，因此如果想要得到sum的旧版本的值，需要进行回溯
1.2 dfs递归：
观察要求我们完成的函数，我们可以归纳出它的功能：询问是否存在从当前节点 root 到叶子节点的路径，满足其路径和为 sum。
假定从根节点到当前节点的值之和为 val，我们可以将这个大问题转化为一个小问题：是否存在从当前节点的子节点到叶子的路径，满足其路径和为 sum - val。
不难发现这满足递归的性质，若当前节点就是叶子节点，那么我们直接判断 sum 是否等于 val 即可（因为路径和已经确定，就是当前节点的值，我们只需要判断该路径和是否满足条件）。若当前节点不是叶子节点，我们只需要递归地询问它的子节点是否能满足条件即可。
public boolean dfs(TreeNode root, int targetSum, int sum) {
if (root == null) {
return false;
}
if (root.left == null && root.right == null) {
return targetSum == sum + root.val;
}
boolean left = dfs(root.left, targetSum, sum + root.val);
boolean right = dfs(root.right, targetSum, sum + root.val);
return left || right;
}
1.3 backtrack回溯(只适用二叉树的先根遍历)
/**
-
Definition for a binary tree node.
-
public class TreeNode {
-
int val; -
TreeNode left; -
TreeNode right; -
TreeNode() {} -
TreeNode(int val) { this.val = val; } -
TreeNode(int val, TreeNode left, TreeNode right) { -
this.val = val; -
this.left = left; -
this.right = right; -
} -
}
*/
class Solution {
boolean flag = false;
int sum = 0;public boolean hasPathSum(TreeNode root, int targetSum) {
if (root == null) {
return flag;
}
myPaths(root, targetSum);
return flag;
}public void myPaths(TreeNode node, int targetSum) {
//采用根左右的先序遍历
sum += node.val;
//终止条件就是滑到叶子节点，即节点的左右子节点都为空
if (node.left == null && node.right == null) {
//按照输出格式输出
if (sum == targetSum) {
flag = true;
}
return;
}
//如果左右节点不为空，那么就继续往下挖，注意挖了之后要回来
//也就是sum-=node.left.val
if (node.left != null) {
myPaths(node.left, targetSum);
sum -= node.left.val;
}
if (node.right != null) {
myPaths(node.right, targetSum);
sum -= node.right.val;
}
}
// 使用外部变量的回溯
public void backtrack(TreeNode root, int targetSum) {if (root == null) { return; } sum += root.val; if (flag) { return; } if (root.left == null && root.right == null && sum == targetSum) { flag = true; return; } backtrack(root.left, targetSum); backtrack(root.right, targetSum); sum -= root.val;}
// 带返回值的回溯
public boolean backtrack2(TreeNode root, int targetSum) {if (root == null) { return false; } sum += root.val; if (root.left == null && root.right == null && sum == targetSum) { return true; } boolean left = backtrack2(root.left, targetSum); boolean right = backtrack2(root.right, targetSum); sum -= root.val; return left || right;}
}
作者：gao-kai-di-zou
链接：https://leetcode-cn.com/problems/path-sum/solution/112-lu-jing-zong-he-hui-su-by-gao-kai-di-vley/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
2 题目二[leetcode-257]
在递归函数中的入口参数是StringBuilder和String时，结果差别很大，因为其两个特性不同，所以代码结构差别比较大
给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。
叶子节点 是指没有子节点的节点。
输入：root = [1,2,3,null,5]
输出：[“1->2->5”,“1->3”]
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/binary-tree-paths
2.1 总结
2.2 中的String类型的入口参数相当于1.2中的int类型的数据作为入口参数，都可以看作是形参的传递（只传递值，不传递地址），而且每调用一次函数，都会将形参复制并保存下来，因此可以能用递归能解决问题；而2.3中的方法参数都是对象，因此是实参传入，属于传入的实际的地址（位于该地址上的数只能保存最新的状态），因此需要回溯从而找到前一步的状态。
2.2 dfs递归方法
可以看到这里的String相当于字符串常量，根据其不变性（即String的每一次变化都被存储起来，且被使用时可以自动搜索常量池）
// 递归
public void dfs(TreeNode root, List list, String path) {
if (root == null) {
return;
}
StringBuilder sB = new StringBuilder(path);
sB.append(root.val);
// 如果当前节点是叶子节点，将当前路径加入结果集
if (root != null && root.right == null && root.left == null) {
list.add(sB.toString());
return;
}
sB.append(“->”);
// 如果当前节点不是叶子节点，继续遍历左子树和右子树
dfs(root.left, list, sB.toString());
dfs(root.right, list, sB.toString());
}
2.3 采用引用传递的方式
（1）backtrack2方法采用StringBuilder方式解决此题，但是因为StringBuilder全局只有一个（采用正常得引用方式传入参数，虽然String传入方式也是引用但是不影响他放入字符常量池），所以需要需要进行回溯；
（2）而对于backtrack方法，其中得List列表也为引用的传递方式（相当于这个方法内部只共用这一个list）
/**
-
Definition for a binary tree node.
-
public class TreeNode {
-
int val; -
TreeNode left; -
TreeNode right; -
TreeNode() {} -
TreeNode(int val) { this.val = val; } -
TreeNode(int val, TreeNode left, TreeNode right) { -
this.val = val; -
this.left = left; -
this.right = right; -
} -
}
*/
class Solution {
List res = new ArrayList<>();
public List binaryTreePaths(TreeNode root) {
List list = new ArrayList<>();
StringBuilder sB = new StringBuilder();
//dfs(root, list, “”);
//backtrack2(root, list, sB);
//return list;
backtrack(root, list);
return res;
}// 回溯算法解决方法一(pass 50%)
public void backtrack2(TreeNode root, List list, StringBuilder sB) {sB.append(root.val); // 如果当前节点是叶子节点，将当前路径加入结果集 if (root != null && root.right == null && root.left == null) { list.add(sB.toString()); return; } // 如果当前节点不是叶子节点，继续遍历左子树和右子树 if (root.left != null) { sB.append("->"); backtrack2(root.left, list, sB); sB.delete(sB.length() - 2, sB.length()); } if (root.right != null) { sB.append("->"); backtrack2(root.right, list, sB); sB.delete(sB.length() - 2, sB.length()); }}
// 回溯算法解决方法二(pass 100%)
public void backtrack(TreeNode root, List path) {
if (root == null) {
return;
}
path.add(String.valueOf(root.val));
// 如果当前节点是叶子节点，将当前路径加入结果集
if (root.right == null && root.left == null) {
StringBuilder sB = new StringBuilder();
for (int i = 0; i < path.size() - 1; i++) {
sB.append(path.get(i) + “->”);
}
sB.append(path.get(path.size() - 1));
res.add(sB.toString());
}// 如果当前节点不是叶子节点，继续遍历左子树和右子树 backtrack(root.left, path); backtrack(root.right, path); path.remove(path.size() - 1); // 回溯}
}
290
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
