深度優先

採用從上至下，將targetsum的值依次減去遍歷過的每個節點的值，最後遍歷到葉子節點，如果葉子節點的值等於最後這個targetsum的值，則說明這條路徑存在

public boolean hasPathSum(TreeNode root, int targetSum) {
          if(root==null){
            return false;
        }
// 說明這個是葉子節點了
        if(root.left==null&&root.right==null){
              return targetsum == root.val;
        }
// 遞迴查詢
        return hasPathSum(root.left,targetsum-root.val)||hasPathSum(root.right,targetsum-root.val);
}
 

廣度優先

廣度優先則採用佇列，橫向遍歷，把每個節點的值依次相加，到葉子節點後，再比較這個值與targetsum是否相等。

 class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if (root == null) {
            return false;
        }
// 兩個佇列。一個存橫向的節點，一個存其值
        Queue<TreeNode> queNode = new LinkedList<TreeNode>();
        Queue<Integer> queVal = new LinkedList<Integer>();
        queNode.offer(root);
        queVal.offer(root.val);
        while (!queNode.isEmpty()) {
            TreeNode now = queNode.poll();// 當前節點
            int temp = queVal.poll();// 當前節點的值
            if (now.left == null && now.right == null) { // 找到葉子節點。判斷是否符合
                if (temp == sum) {
                    return true;
                }
                continue;
            }
// 廣度優先，**注意**：這裡存的值，是上面往下面，遍歷到的值得總和
            if (now.left != null) {
                queNode.offer(now.left);
                queVal.offer(now.left.val + temp);
            }
            if (now.right != null) {
                queNode.offer(now.right);
                queVal.offer(now.right.val + temp);
            }
        }
        return false;
    }
}