653. Two Sum IV - Input is a BST（python+cpp）

Given a Binary Search Tree and a target number, return true if there exist two elements in the BST such that their sum is equal to the given target
Example 1:

Input: 
    5  
   / \   
  3   6  
 / \   \ 
2   4   7
Target = 9 
Output: True

Example 2:

Input: 
    5   
   / \   
  3   6  
 / \   \ 
2   4   7
Target = 28
Output: False

解释：
输入是一颗二叉树，第一反应是先遍历一遍二叉树把树的结点的值存成list，然后用Two Sum II的解法做（因为BST中序遍历以后是有序的），后来反应过来可以直接在遍历的过程中存dict，无需先存成有序list，这里其实是被BST的中序有序性质迷惑了。
刚开始的想法，python代码，速度极慢：

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

class Solution(object):
    def middle(self,root,a):
        if root==None:
            return None
        self.middle(root.left,a)
        a.append(root.val)
        self.middle(root.right,a)
        return a
    def findTarget(self, root, k):
        """
        :type root: TreeNode
        :type k: int
        :rtype: bool
        """
        b=[]
        a=self.middle(root,b)
        print a
        i=0
        j=len(a)-1
        while i<j:
            if a[i]+a[j]<k:
                i+=1
            elif a[i]+a[j]>k:
                j-=1
            else:
                return True
        return False

实际上前序遍历一遍即可。

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

class Solution(object):
    def findTarget(self, root, k):
        """
        :type root: TreeNode
        :type k: int
        :rtype: bool
        """
        _set=set()
        def dfs(root):
            if not root:
                return False
            if k-root.val in _set:
                return True
            _set.add(root.val)
            return dfs(root.left) or dfs(root.right)
        return dfs(root) 

c++代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
#include<set>
using namespace std;
class Solution {
public:
    set<int> _set;
    bool findTarget(TreeNode* root, int k) {
        return dfs(root,k)  
    }
    bool dfs(TreeNode *root ,int k)
    {
        if (! root)
            return false;
        if(count(_set.begin(),_set.end(),k-root->val))
            return true;
        _set.insert(root->val);
        return dfs(root->left,k)||dfs(root->right,k);
    }
};

总结：
对于二叉树的问题，有时候或许可以直接在遍历的时候处理一些事情，不一定非要遍历完了再处理。