【LeetCode每日一题】——653.两数之和 IV - 输入二叉搜索树

一【题目类别】

• 广度优先搜索

二【题目难度】

• 简单

三【题目编号】

• 653.两数之和 IV - 输入二叉搜索树

四【题目描述】

• 给定一个二叉搜索树root和一个目标结果k，如果二叉搜索树中存在两个元素且它们的和等于给定的目标结果，则返回true。

五【题目示例】

• 示例 1：
  

  • 输入: root = [5,3,6,2,4,null,7], k = 9
  • 输出: true

• 示例 2：
  

  • 输入: root = [5,3,6,2,4,null,7], k = 28
  • 输出: false

六【题目提示】

• 二叉树的节点个数的范围是$[1,10^4]$.
• $-10^4<=Node.val<=10^4$
• 题目数据保证，输入的root是一棵 有效 的二叉搜索树
• $-10^5<=k<=10^5$

七【解题思路】

• 想要解决该问题我们就要明确两个问题：
  • 正确的遍历二叉搜索树：这个问题很好解决，采用BFS或者DFS都可以，我采用的是BFS
  • 如何计算两数之和：其实可以将该问题转换为如何计算两数之差。假设x + y = k（其中x和y是二叉搜索树的节点值，k为目标值），当我们遍历到x时，计算k - x = y，查看此时k - x = y是否在哈希表中，如果在，说明之前遍历到值为k - x = y的节点，反之说明当前节点与之前遍历到的节点值和并不是k，所以将当前节点的值（即x）加入到哈希表中。然后不断地重复该过程，直到该二叉搜索树遍历完毕

八【时间频度】

• 时间复杂度：$O(n)$，$n$为传入的二叉树的节点个数
• 空间复杂度：$O(n)$，$n$为传入的二叉树的节点个数

九【代码实现】

1. Java语言版

/**
 * 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 {
    public boolean findTarget(TreeNode root, int k) {
        Set<Integer> hash = new HashSet<Integer>();
        Queue<TreeNode> queue = new ArrayDeque<TreeNode>();
        queue.offer(root);
        while (!queue.isEmpty()){
            TreeNode node = queue.poll();
            if (hash.contains(k - node.val)){
                return true;
            }
            hash.add(node.val);
            if (node.left != null){
                queue.offer(node.left);
            }
            if (node.right != null){
                queue.offer(node.right);
            }
        }
        return false;
    }
}

2. Python语言版

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

class Solution:

    def findTarget(self, root: Optional[TreeNode], k: int) -> bool:
        hashset = set()
        q = deque([root])
        while q:
            node = q.popleft()
            if k - node.val in hashset:
                return True
            hashset.add(node.val)
            if node.left:
                q.append(node.left)
            if node.right:
                q.append(node.right)
        return False

3. C++语言版

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool findTarget(TreeNode* root, int k) {
        unordered_set<int> hash;
        queue<TreeNode*> queue;
        queue.push(root);
        while (!queue.empty()){
            TreeNode *node = queue.front();
            queue.pop();
            if (hash.count(k - node->val)){
                return true;
            }
            hash.insert(node->val);
            if (node->left != nullptr){
                queue.push(node->left);
            }
            if (node->right != nullptr){
                queue.push(node->right);
            }
        }
        return false;
    }
};

十【提交结果】

1. Java语言版
   

2. Python语言版
   

3. C++语言版