LintCode 689. Two Sum IV - Input is a BST

纸上得来终觉浅绝知此事要躬行

已于 2023-11-30 03:40:54 修改

阅读量248

点赞数

CC 4.0 BY-SA版权

分类专栏： algorithm-design 文章标签： LintCode

于 2019-04-28 02:23:58 首次发布

本文链接：https://blog.youkuaiyun.com/roufoo/article/details/89629597

algorithm-design 专栏收录该内容

817 篇文章

订阅专栏

本文探讨了在二叉搜索树中寻找两个数使其和等于给定值的问题，提供了两种解决方案：一是结合中序遍历与二叉搜索树特性进行查找，二是利用层次遍历配合hashmap实现。第一种方法避免使用额外空间，第二种方法则通过hashmap提高查找效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Two Sum IV - Input is a BST
中文English
Given a binary search tree and a number n, find two numbers in the tree that sums up to n.

Example
Example1

Input:
{4,2,5,1,3}
3
Output: [1,2] (or [2,1])
Explanation:
binary search tree:
4
/
2 5
/
1 3
Example2

Input:
{4,2,5,1,3}
5
Output: [2,3] (or [3,2])
Notice
Without any extra space.

注意：这题要求不用extra space，所以不能保存inOrderTraversal的结果，也不能用set或map之类。

解法1：
一边inOrderTraversal一边BST查找，效率好像不是很高 (O(nlogn))?
代码如下：

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /*
     * @param : the root of tree
     * @param : the target sum
     * @return: two number from tree witch sum is n
     */
    vector<int> twoSum(TreeNode * root, int n) {
        if (!root || n <= 0) return vector<int>();
        origRoot = root;
        inOrderTraversal(root, n);
        return result;
    }
    
private:
    TreeNode * origRoot;
    vector<int> result;
    
    bool bst(TreeNode * root, int target) {
        if (!root) return false;
        if (root->val > target) return bst(root->left, target);
        if (root->val < target) return bst(root->right, target);
        return true;
    }
    
    void inOrderTraversal(TreeNode * root, int n) {
        if (!root) return;
        inOrderTraversal(root->left, n);
        if (bst(origRoot, n - root->val)) result = vector<int>{root->val, n - root->val};
        inOrderTraversal(root->right, n);
    }
    
    
};

解法2：层次遍历+hashmap

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /*
     * @param : the root of tree
     * @param : the target sum
     * @return: two number from tree witch sum is n
     */
    vector<int> twoSum(TreeNode * root, int n) {
        if (!root) return {};
        unordered_set<int> us;
        queue<TreeNode *> q;
        vector<int> res;
        q.push(root);
        us.insert(root->val);
        while (!q.empty()) {
            TreeNode *frontNode = q.front();
            q.pop();
            if (us.find(n - frontNode->val) != us.end()) {
                return {frontNode->val, n - frontNode->val};
            }
            if (frontNode->left) {
                q.push(frontNode->left);
                us.insert(frontNode->left->val);
            }
            if (frontNode->right) {
                q.push(frontNode->right);
                us.insert(frontNode->right->val);
            }
        }
        return {};
    }
};