LeetCode 653. 两数之和 IV - 输入 BST

最新推荐文章于 2024-06-12 10:00:23 发布

小明不要写Bug

最新推荐文章于 2024-06-12 10:00:23 发布

阅读量601

点赞数

分类专栏： LeetCode 每日一题题解 # 迭代 # 深搜、广搜文章标签： leetcode c++ java 哈希

本文链接：https://blog.csdn.net/qq_46176960/article/details/123626260

版权

LeetCode 每日一题题解同时被 3 个专栏收录

92 篇文章 2 订阅

订阅专栏

深搜、广搜

14 篇文章 0 订阅

订阅专栏

迭代

4 篇文章 0 订阅

订阅专栏

653. 两数之和 IV - 输入 BST题解

题目来源：653. 两数之和 IV - 输入 BST

2022.03.21 每日一题

LeetCode 题解持续更新中Github仓库地址 CSDN博客地址

今天的题目很简单，就是简简单单的搜索就好

法一：递归+哈希

使用一个 HashSet 用来统计数字是否出现过，如果 k - val 的值出现过，则说明 BST 中，有两个数字相加等于 k，返回 true

class Solution {
    // 创建一个 HashSet 用来统计数字是否出现
    unordered_set<int> set;
public:
    bool findTarget(TreeNode *root, int k) {
        // 如果根节点为空，或者搜索到结尾，仍然没有搜索到答案，则返回 false
        if (root == nullptr) return false;
        // 如果在过去查找到的数字中，找到了 k - root.val 的值，就说明在 BST 中存在两个数相加等于 k
        if (set.count(k - root->val)) return true;
        // 如果不满足上面两个条件，就将当前的 val 加入到 set 中便于 后续查找
        set.insert(root->val);
        // 继续进行递归搜索
        return findTarget(root->left, k) || findTarget(root->right, k);
    }
};

class Solution {
    // 创建一个 HashSet 用来统计数字是否出现
    HashSet<Integer> set = new HashSet<>();

    public boolean findTarget(TreeNode root, int k) {
        // 如果根节点为空，或者搜索到结尾，仍然没有搜索到答案，则返回 false
        if (root == null) return false;
        // 如果在过去查找到的数字中，找到了 k - root.val 的值，就说明在 BST 中存在两个数相加等于 k
        if (set.contains(k - root.val)) return true;
        // 如果不满足上面两个条件，就将当前的 val 加入到 set 中便于 后续查找
        set.add(root.val);
        // 继续进行递归搜索
        return findTarget(root.left, k) || findTarget(root.right, k);
    }
}

法二：BFS+哈希

这个方法与法一相似，都是首先遍历一颗树，然后判断 k - val 的值是否出现过

class Solution {
    // 创建一个 HashSet 用来统计数字是否出现
    unordered_set<int> set;
public:
    bool findTarget(TreeNode *root, int k) {
        // 创建一个队列用于进行 BFS
        queue<TreeNode *> qu;
        // 前序遍历的模板
        qu.push(root);
        while (!qu.empty()) {
            TreeNode *node = qu.front();
            qu.pop();
            // 如果在 查找中发现了 k - node->val 的值，就说明在 BST 中 有两个数相加等于 k，返回 true
            if (set.count(k - node->val)) return true;
            set.insert(node->val);
            // 注意不要放入空节点
            if (node->left != nullptr) qu.push(node->left);
            if (node->right != nullptr) qu.push(node->right);
        }
        // 如果不存在就返回 false
        return false;
    }
};

class Solution {
    // 创建一个 HashSet 用来统计数字是否出现
    HashSet<Integer> set = new HashSet<>();

    public boolean findTarget(TreeNode root, int k) {
        // 创建一个队列用于进行 BFS
        Deque<TreeNode> qu = new ArrayDeque<>();
        // 前序遍历的模板
        qu.push(root);
        while (!qu.isEmpty()) {
            TreeNode node = qu.poll();
            // 如果在 查找中发现了 k - node->val 的值，就说明在 BST 中 有两个数相加等于 k，返回 true
            if (set.contains(k - node.val)) return true;
            set.add(node.val);
            // 注意不要放入空节点
            if (node.left != null) qu.push(node.left);
            if (node.right != null) qu.push(node.right);
        }
        // 如果不存在就返回 false
        return false;
    }
};

法三：中序遍历+双指针

本题目使用的是 BST，BST 的一个性质就是 $n o d e . l e f t . v a l < n o d e . v a l < n o d e . r i g h t . v a l$ ，因此我们可以使用中序遍历，从而得到一个有序数组，再通过双指针的方法，来判断，是否存在两个节点的值相加等于k

有关树的遍历，方法都在这里传送门，后期有关于 BST 的内容也会补充进去

通过递归的方法实现中序遍历

class Solution {
public:
    // 创建一个数组 cnt，用来统计 BST 中的各个元素
    vector<int> cnt;

    bool findTarget(TreeNode *root, int k) {
        dfs(root);
        // 双指针进行查找
        int l = 0, r = cnt.size() - 1;
        while (l < r)
            // 如果找到了，就返回 true
            if (cnt[l] + cnt[r] == k) return true;
            else if (cnt[l] + cnt[r] < k) l++;
            else r--;
        // 反之 返回 false
        return false;
    }

    // 中序遍历
    void dfs(TreeNode *node) {
        if (node == nullptr) return;
        dfs(node->left);
        cnt.push_back(node->val);
        dfs(node->right);
    }
};

class Solution {
    // 创建一个 HashSet 用来统计数字是否出现
    HashSet<Integer> set = new HashSet<>();
    // 定义结果数组
    public ArrayList<Integer> cnt = new ArrayList<>();

    public boolean findTarget(TreeNode root, int k) {
        dfs(root);
        // 双指针进行查找
        int l = 0, r = cnt.size() - 1;
        while (l < r)
            // 如果找到了，就返回 true
            if (cnt.get(l) + cnt.get(r) == k) return true;
            else if (cnt.get(l) + cnt.get(r) < k) l++;
            else r--;
        // 反之 返回 false
        return false;
    }


    void dfs(TreeNode root) {
        // 如果当前的节点是空节点，就直接结束递归
        if (root == null) return;

        // 模拟左中右的方式
        // 探寻左节点
        dfs(root.left);
        // 将当前节点的 val 值加入结果数组之中
        cnt.add(root.val);
        // 探寻右节点
        dfs(root.right);
    }
};

通过迭代的方法实现中序遍历

class Solution {
public:
    // 创建一个数组 cnt，用来统计 BST 中的各个元素
    vector<int> cnt;

    bool findTarget(TreeNode *root, int k) {
        // 迭代法
        inorderTraversal(root);
        // 双指针进行查找
        int l = 0, r = cnt.size() - 1;
        while (l < r)
            // 如果找到了，就返回 true
            if (cnt[l] + cnt[r] == k) return true;
            else if (cnt[l] + cnt[r] < k) l++;
            else r--;
        // 反之 返回 false
        return false;
    }

    void inorderTraversal(TreeNode *root) {
        // 创建栈，以用来存放节点
        stack<TreeNode *> st;
        // 进入迭代
        while (root != nullptr || !st.empty()) {
            // 首先先将左节点压入 栈 中
            // 原因：中序遍历首先是以 左节点开始的，首先要找到最左端的节点
            while (root != nullptr) {
                st.push(root);
                root = root->left;
            }
            root = st.top();
            st.pop();
            // 压入相应的值
            cnt.push_back(root->val);
            // 然后遍历右侧节点
            root = root->right;
        }
    }
};

class Solution {
    // 创建一个 HashSet 用来统计数字是否出现
    HashSet<Integer> set = new HashSet<>();
    // 定义结果数组
    public ArrayList<Integer> cnt = new ArrayList<>();

    public boolean findTarget(TreeNode root, int k) {
        inorderTraversal(root);
        // 双指针进行查找
        int l = 0, r = cnt.size() - 1;
        while (l < r)
            // 如果找到了，就返回 true
            if (cnt.get(l) + cnt.get(r) == k) return true;
            else if (cnt.get(l) + cnt.get(r) < k) l++;
            else r--;
        // 反之 返回 false
        return false;
    }


    public void inorderTraversal(TreeNode root) {
        // 创建栈，以用来存放节点
        ArrayDeque<TreeNode> st = new ArrayDeque<>();

        // 进入迭代
        while (root != null || !st.isEmpty()) {
            // 首先先将左节点压入 栈 中
            // 原因：中序遍历首先是以 左节点开始的，首先要找到最左端的节点
            while (root != null) {
                st.add(root);
                root = root.left;
            }
            root = st.pop();

            // 压入相应的值
            cnt.add(root.val);
            // 然后遍历右侧节点
            root = root.right;
        }
    }
}