题目描述（困难难度）

124*. Binary Tree Maximum Path Sum - 图1

考虑一条路径，可以从任意节点开始，每个节点最多经过一次，问经过的节点的和最大是多少。

解法一 递归

参考了 这里。

首先看到二叉树的题，肯定就是想递归了。递归常规的思路，肯定是递归考虑左子树的最大值，递归考虑右子树的最大值。

  1. public int maxPathSum(TreeNode root) {
  2.     if (root == null) {
  3.         return Integer.MIN_VALUE;
  4.     }
  5.     //左子树的最大值
  6.     int left = maxPathSum(root.left);
  7.     //右子树的最大值
  8.     int right = maxPathSum(root.right);  
  9.     //再考虑包含根节点的最大值
  10.     int  all = ....;
  11.     return Math.max(Math.max(left, right), all);
  12. }

问题就来了，怎么考虑包含根节点的最大路径等于多少？因为我们递归求出来的最大 left 可能不包含根节点的左孩子，例如下边的情况。

  1.      8
  2.     / \
  3.   -3   7
  4.  /  \
  5. 1    4

左子树的最大值 left 肯定就是 4 了，然而此时的根节点 8 并不能直接和 4 去相连。所以考虑包含根节点的路径的最大值时，并不能单纯的用 root.val + left + right。

所以如果考虑包含当前根节点的 8 的最大路径，首先必须包含左右孩子，其次每次遇到一个分叉，就要选择能产生更大的值的路径。例如下边的例子：

  1.       8
  2.     /  \
  3.    -3   7
  4.  /    \
  5. 1      4
  6.  \    / \    
  7.   3  2   6
  9. 考虑左子树 -3 的路径的时候，我们有左子树 1 和右子树 4 的选择，但我们不能同时选择
  10. 如果同时选了，路径就是 ... -> 1 -> -3 -> 4 -> ... 就无法通过根节点 8 了
  11. 所以我们只能去求左子树能返回的最大值，右子树能返回的最大值，选一个较大的

假设我们只考虑通过根节点 8 的最大路径是多少，那么代码就可以写出来了。

  2. public int maxPathSum(TreeNode root) {
  3.     //如果最大值是负数，我们选择不选
  4.     int left = Math.max(helper(root.left), 0);
  5.     int right = Math.max(helper(root.right), 0); 
  6.     return root.val + left + right;
  7. }
  9. int helper(TreeNode root) {
  10.     if (root == null) return 0; 
  11.     int left = Math.max(helper(root.left), 0);
  12.     int right = Math.max(helper(root.right), 0);  
  13.     //选择左子树和右子树产生的值较大的一个
  14.     return root.val + Math.max(left, right);
  15. }

接下来我觉得就是这道题最精彩的地方了，现在我们只考虑了包含最初根节点 8 的路径。那如果不包含当前根节点，而是其他的路径呢？

可以发现在 helper 函数中，我们每次都求了当前给定的节点的左子树和右子树的最大值，和我们 maxPathSum 函数的逻辑是一样的。所以我们利用一个全局变量，在考虑 helper 函数中当前 root 的时候，同时去判断一下包含当前 root 的路径的最大值。

这样在递归过程中就考虑了所有包含当前节点的情况。

  1. int max = Integer.MIN_VALUE;
  3. public int maxPathSum(TreeNode root) {
  4.     helper(root);
  5.     return max;
  6. } 
  7. int helper(TreeNode root) {
  8.     if (root == null) return 0;
  10.     int left = Math.max(helper(root.left), 0);
  11.     int right = Math.max(helper(root.right), 0);
  13.     //求的过程中考虑包含当前根节点的最大路径
  14.     max = Math.max(max, root.val + left + right);
  16.     //只返回包含当前根节点和左子树或者右子树的路径
  17.     return root.val + Math.max(left, right);
  18. }

总

这道题最妙的地方就是在递归中利用全局变量，来更新最大路径的值，太强了。前边遇到过和全局变量结合的递归，例如 106 题，当递归和全局变量结合有时候确实会难理解些。而在 110 题 中也应用了和这个题一样的思想，就是发现递归过程和主函数有一样的逻辑，此时可以在递归过程中就可以进行求解。

windliang wechat

添加好友一起进步~

如果觉得有帮助的话，可以点击 这里 给一个 star 哦 ^^

如果想系统的学习数据结构和算法，强烈推荐一个我之前学过的课程，可以点击 这里 查看详情