LeetCode刷题

两个总和 - 输入是BST

描述
给定一个二进制搜索树和一个目标编号，如果BST中存在两个元素，则它们的和等于给定目标，则返回true。

方法一：

这种方法也适用于那些不是BST的情况。 这个想法是使用散列表来保存BST中节点的值。 每当我们将新节点的值插入散列表时，我们检查散列表是否包含k-node.val。

时间复杂度: O(n), 空间复杂度: O(n).
- Java version:

public boolean findTarget(TreeNode root, int k){
    HashSet<integer> set = new HashSet<>();
    return dfs(root, set, k);
}

public boolean dfs(TreeNode root, HashSet<Integer> set, int k){
    if(root == null) return false;
    if(set.contains(k - root.val)) return true;
    set.add(root.val);
    return dfs(root.left, set, k) || dfs(root.right, set, k);
}

• C++ 版本

bool findTarget(TreeNode* root, int k){
    unordered_set<int> set;
    return dfs(root, set, k);
}

bool dfs(TreeNode* root, unordered_set<int>& set, int k){
    if(root == NULL) return false;
    if(set.count(k - root->val)) return true;
    set.insert(root->val);
    return dfs(root->left, set, k) || dfs(root->right, set, k); 
}

方法2

这个想法是使用排序数组通过使用中序遍历来保存BST中的节点的值。 然后，我们使用两个指针，从数组的开始和结尾开始，查找是否有和k。
时间复杂度: O(n), 空间复杂度: O(n).

• java版本

public boolean findTargrt(TreeNode root, int k){
    List<Integer> nums = new ArrayList<>();
    inorder(root, nums);
    for(int i=0, j=nums.size()-1; i<j;){
        if(nums.get(i) + nums.get(j) == k) return true;
        if(nums.get(i) + nums.get(j) < k) i++;
        else j--;
    }
    return false;
}

public void inorder(TreeNode root, List<Integer> nums){
    if(root == null) return;
    inorder(root.left, nums);
    nums.add(root.val);
    inorder(root.right, nums);
}

• C++版本

bool findTarget(TreeNode* root, int k){
    vector<int> nums;
    inorder(root, nums);
    for(int i=0, j=nums.size()-1; i<j;){
        if(nums[i] + nums[j] == k) return true;
        (nums[i] + nums[j] < k)? i++ : j--;
    }
    return false;
}

void inorder(TreeNode* root, vector<int>& nums){
    if(root == NULL) return;
    inorder(root->left, nums);
    nums.push_back(root->val);
    inorder(order->right, nums)
}

方法3：

这个想法是使用二进制搜索方法。 对于每个节点，我们检查在这个BST中是否存在k-node.val。时间复杂度：O（nlogn），空间复杂度：O（h）。 h是树的高度，logn最好，n最差。(有点看不懂- _ - ||)

• java版本

public boolean findTarget(TreeNode root, int k){
    return dfs(root, root, k);
}

public boolean dfs(TreeNode root, TreeNode cur, int k){
    if(cur == null) return falsel;
    return search(root, cur, k-cur.val) || dfs(root, cur.left, k) || dfs(root, cur.right, k)
}

public boolean search(TreeNode root, TreeNode cur, int value){
    if(root == null) return false;
    return (root.val == value) && (root != cur)
        || (root.val < value) && search(root.right, cur, value)
            || (root.val > value) && search(root.left, cur, value);
}

• C++版本

bool findTarget(TreeNode* root, int k){
    return dfs(root, root, k);
}

bool dfs(TreeNode* root, TreeNode* cur, int k){
    if(root == NULL) return false;
    return search(root, cur, k-cur->val) || dfs(root, cur->left, k) 
        || dfs(root, cur->right, k)
}

bool search(TreeNode* root, TreeNode *cur, int value){
    if(root == NULL) return false;
    return (root->val == value) && (root != cur)
        || (root->val < value) && search(root->right, cur, value)
            || (root->val > value) && search(root->left, cur, value)
}

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

///////////////////////////////////////////////////
class Solution {
    public boolean findTarget(TreeNode root, int k) {
        if (root == null) {
            return false;
        }

        // Use Deque as Stack
        Deque<TreeNode> leftSide = new ArrayDeque<>();
        Deque<TreeNode> rightSide = new ArrayDeque<>();

        // Find the greatest and smallest Node in the Tree first.
        TreeNode tmp = root;
        while (tmp != null) {
            leftSide.push(tmp);
            tmp = tmp.left;
        }
        tmp = root;
        while (tmp != null) {
            rightSide.push(tmp);
            tmp = tmp.right;
        }

        // Then perform the same 2 pointer idea like we are facing a sorted list
        // However, in this case, we always try to traverse the tree to looking
        // for the next smaller or larger TreeNode. This is applicable since 
        // this is a BST.
        TreeNode left = leftSide.pop();
        TreeNode right = rightSide.pop();

        while (left.val != right.val) {
            // If there is no redundant number in the Tree, 
            // then left.val == right.val can indicates a thorough search is completed.
            int currSum = left.val + right.val;
            if (currSum == k) {
                return true;
            } else if (currSum < k) {
                if (left.right != null) {
                    left = left.right;
                    while (left != null) {
                        leftSide.push(left);
                        left = left.left;
                    }
                }
                left = leftSide.pop();
            } else { // currSum > k
                if (right.left != null) {
                    right = right.left;
                    while (right != null) {
                        rightSide.push(right);
                        right = right.right;
                    }
                }
                right = rightSide.pop();
            }
        }

        return false;
    }
}