112. Path Sum

Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.

Note: A leaf is a node with no children.

Example:

Given the below binary tree and sum = 22,

5
     / \
    4   8
   /   / \
  11  13  4
 /  \      \
7    2      1

return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.

Analyze

使用递归的思路进行解题:

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} sum
 * @return {boolean}
 */
var hasPathSum = function(root, sum) {
  if (!root) return false
  return ifHasPathSum(root, sum)
}

var ifHasPathSum = function(node, sum) {
  if (!node && sum !== 0) return false
  if (!node && sum === 0) return true
  const remainingVal = sum - node.val
  const leftResult = ifHasPathSum(node.left, remainingVal)
  if (leftResult) return true
  const rightResult = ifHasPathSum(node.right, remainingVal)
  if (rightResult) return true
  return false
}

此时 ac, 卡在了以下测试用例中(此题的难点在于对递归终止条件的判断)

1
  /   \
null   2

先对代码进行整理精简:

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} sum
 * @return {boolean}
 */
var hasPathSum = function(root, sum) {
  if (!root) return false
  return ifHasPathSum(root, sum)
}

var ifHasPathSum = function(node, sum) {
  if (!node) return sum === 0
  const remainingVal = sum - node.val
  return ifHasPathSum(node.left, remainingVal) || ifHasPathSum(node.right, remainingVal)
}

终止条件应由判断当前节点为空而且 sum === 0调整为判断当前节点为叶子节点且 node.val === sum, 再次修正代码

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} sum
 * @return {boolean}
 */
var hasPathSum = function(root, sum) {
  if (!root) return false
  if (!root.left && !root.right) return root.val === sum
  const remainingVal = sum - root.val
  return hasPathSum(root.left, remainingVal) || hasPathSum(root.right, remainingVal)
}