二叉树路径问题
二叉树路径问题主要是集中在查找二叉树路径、计算路径和之类的问题，个人理解是在二叉树遍历的基础上不断加盐升级的问题。本文为个人笔记，主要总结归纳二叉树路径相关的问题。
二叉树的所有路径
［力扣２５７,二叉树的所有路径］(https://leetcode-cn.com/problems/binary-tree-paths/),比较简单只在二叉树遍历的基础上增加了记录路径的要求，关键点在于到达叶子节点的时候记录路径好。方法签名如下：
public List binaryTreePaths(TreeNode root){}
遍历的模板迭代或递归，参考算法笔记之二叉树遍历。
class Solution {
public List<String> binaryTreePaths(TreeNode root) {
if (root == null) {
return new ArrayList<>();
}
List<String> list = new ArrayList<>();
binaryTreePathsHelper(root, list, "");
return list;
}
private void binaryTreePathsHelper(TreeNode root, List<String> list, String origin) {
if (root == null) {
return;
}
StringBuilder stringBuilder = new StringBuilder(origin).append(root.val);
if (root.left == null && root.right == null) {
list.add(stringBuilder.toString());
} else {
String str = stringBuilder.append("->").toString();
binaryTreePathsHelper(root.left, list, str);
binaryTreePathsHelper(root.right, list, str);
}
}
}
路径总和
路径总和的问题要求是给出一个树节点和和一个值判断，判断路径总和有没有和他相等的。详情参考本题在找到所有路径的基础上增加要求判断目标路径和的存在性。使用简单的递归迭代即可解决问题。
public boolean hasPathSum(TreeNode root, int targetSum) {
if(root == null){
return false;
}
if(root.left == null && root.right == null){
return root.val == targetSum;
}
boolean lResult = hasPathSum(root.left,tagetSum - root.val);
if(lResult){
return true;
}
return hasPathSum(root.right,tagetSum - root.val);
}
从叶子节点开始的最小字符串
类似路径总和，加了对值的处理和保存。力扣问题详情
String res = null;
public String smallestFromLeaf(TreeNode root) {
if (root == null) {
throw new IllegalArgumentException("参数异常");
}
smallestFromLeafHelper(root, new StringBuilder());
return res;
}
private void smallestFromLeafHelper(TreeNode root, StringBuilder str) {
if (root == null) {
return;
}
//做出选择
str.insert(0, (char) (root.val + 97));
//判断
if (root.left == null && root.right == null) {
String s = str.toString();
if (res == null || s.compareTo(res) < 0) {
res = s;
}
} else {
smallestFromLeafHelper(root.left, str);
smallestFromLeafHelper(root.right, str);
}
//撤销选择
str.delete(0, 1);
}
路径总和 II
继续加盐，二叉树的路径找到了之后也能判断目标路径总和是否存在，我又想在路径集合中挑出和为指定值的路径。详情参考力扣112题。递归的问题都是具有回溯性的。参考labuladong大神给出的模板去解决此类问题做出选择 -> 判断选择 -> 撤销选择。
private int count = 0;
List<Integer> tmp = new ArrayList<>();
public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
if (root == null) {
return new ArrayList<>();
}
List<List<Integer>> list = new ArrayList<>();
pathSumHelper(root, list, targetSum);
return list;
}
private void pathSumHelper(TreeNode root, List<List<Integer>> list, int targetSum) {
if (root == null) {
return;
}
//做出选择
tmp.add(root.val);
count += root.val;
//判断该选择的是否满足条件
if (root.left == null && root.right == null && count == targetSum) {
list.add(new ArrayList<>(tmp));
} else {
pathSumHelper(root.left, list, targetSum);
pathSumHelper(root.right, list, targetSum);
}
//撤销选择
tmp.remove(tmp.size() - 1);
count -= root.val;
}
路径总和 III
路径总和 III，继续加盐，找出所有路径总和为目标值的数量，这次路径的起点不限制为根，终点也不限制叶子节点但是路径的方向必须是向下的。
前缀和的方式：
int count = 0;
public int pathSum(TreeNode root, int sum) {
Map<Integer, Integer> prefixSumCount = new HashMap<>();//用于存放上层节点前缀和对应的个数
prefixSumCount.put(0, 1);//解决前缀和刚好为target的节点计数（包括两种：例target = 8时，单节点[8] 或 [1,2,5]）
recursionPathSum(root, prefixSumCount, sum, 0);
return count;
}
private void recursionPathSum(TreeNode node, Map<Integer, Integer> prefixSumCount, int target, int currSum) {
if (node == null) {
return;
}
currSum += node.val;
//做出选择并校验选择
count += prefixSumCount.getOrDefault(currSum - target, 0);
prefixSumCount.put(currSum, prefixSumCount.getOrDefault(currSum, 0) + 1);
//递归
recursionPathSum(node.left, prefixSumCount, target, currSum);
recursionPathSum(node.right, prefixSumCount, target, currSum);
//撤销选择
prefixSumCount.put(currSum, prefixSumCount.get(currSum) - 1);
}
/*纯递归的方式时间复杂度较高，可以理解一下子问题的划分
public int pathSum(TreeNode root, int targetSum) {
if (root == null) return 0;
int ret = pathSumStartWithRoot(root, targetSum) + pathSum(root.left, targetSum) + pathSum(root.right, targetSum);
return ret;
}
// 以root 为根节点的路径和数量
private int pathSumStartWithRoot(TreeNode root, int sum) {
if (root == null) return 0;
int ret = 0;
if (root.val == sum) ret++;
ret += pathSumStartWithRoot(root.left, sum - root.val) + pathSumStartWithRoot(root.right, sum - root.val);
return ret;
}*/
基本模板是类似，复杂度均为O(n)。其中回溯的状态值保存在散列表中，校验的操作实际是分散了。处理逻辑很巧妙。
124. 二叉树中的最大路径和
继续增加限制，以上的所有题目路径的方向都是自上而下的。现在不限制方向了，求二叉树的最大路径和。题目一下子升级到困难级别。
int maxSum = Integer.MIN_VALUE;
public int maxPathSum(TreeNode root) {
maxPathSumHelper(root);
return maxSum;
}
public int maxPathSumHelper(TreeNode root) {
if (root == null) {
return 0;
}
//为什么和0比较？要是最大和和比0还小那么这侧就可以忽略了
int leftMaxSum = Math.max(maxPathSumHelper(root.left), 0);
int rightMaxSum = Math.max(maxPathSumHelper(root.right), 0);
//计算左根右的最大路径和
maxSum = Math.max(maxSum, leftMaxSum + rightMaxSum + root.val);
//返回当前节点最大和（自上向下的方向）
return root.val + Math.max(leftMaxSum, rightMaxSum);
}
