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

方法一 ：使用 HashSet

• List item
• set
• 无序 不重复
  判断某物是否已近存在于集合中,不会存储重复的元素
• set .add
• Iterator it = set.iterator();
  while (it.hasNext()) {
  System.out.println(it.next());
  }
• set.contains();

|| 前面为ture 后面就不执行
时间复杂度：O(n)，其中 N 是节点的数量。最坏的情况下，整棵树被遍历一次。
空间复杂度：O(n)。最坏的情况下，set 存储 n 个节点的值。

算法理解

问题：为什么先对比了再放
如果放了以后再对比，比如 target = 10 ,root = 5,先放了，set里有5，就会直接返回true;
对比是和除自己以外的其他元素对比，其他元素都在set里，对比的时候set里不能包括自己。利用set不重复的特点，所以可以对比完再放不用担心会和自己对比到。
并且倘若BST里有重复的元素，比如两个5，先对比再放，也可以保证对比到的5是之前放的那个，就直接返回true了，不用再放入set，会被覆盖。

分析：
这个算法本质是什么呢，就是
先遍历一遍全部BST,把里面的元素全部都放入set;
再遍历一遍元素，一一和set里的元素对比；
但是这样有坏处，会和自己对比到，而且两遍遍历，代码冗余

理解：
找到一个值，在屋子（set）里找找有没有值和他匹配，如果没有，就自己先进入屋子（不用担心外面或许还存在满足条件的值，因为他们也迟早会进入屋子的，到时候自己在屋子里，双方迟早会见面），也不用担心外面万一有两个值和自己匹配（好纠结，要选哪个呢），你想多了，题目只要求你能够找到（存在值相加等于target），才不关心你找哪个呢，找着谁并不重要,所以，就让你和先见到的那个走吧。（我突然发现人生很多时候就是这样，相识很晚。外面排着队的就是整个人类社会，你一生只会遇见很少很少一部分人）
于是返回true，（因为是递归 加上 或者|| ，满足其中一个true,算法就结束，一次次向上传递true）
你进入屋子后，外面排着队的值，每次都会和已经在屋子里的值做个匹配，找着了就算完，没找着就进屋子里等着别人来找。
那么问题来了，为什么非得进入屋子匹配（用set）呢, 排着队的时候怎么就不找呢（BST）,因为你排着队的时候找就得一个个去找，太麻烦了，这个屋子好哇，它有个机制，你一进去，它就给你的脸扫入系统，匹配的时候刷的一下就能找到（set.contains()），你等的时间最多也就是O(n)，这么多人，要占O（n）个的地方。

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

作者：LeetCode
链接：https://leetcode-cn.com/problems/two-sum-iv-input-is-a-bst/solution/liang-shu-zhi-he-iv-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

方法二：使用 BFS 和 HashSet

• 广度优先搜索算法

1. 满足先生成的结点先扩展的原则，所以存储结点的表一般采用队列这种数据结构。
2. 放入根， 取出根，放入根的左右节点ab,取出左节点a ,放入a的左右节点；取出b，放入b的左右节点；。。。。（类似树的层序遍历，利用了队列先进先出的特点）

• 队列

3. Queue 中 element() 和 peek() 都是用来返回队列的头元素，不删除。
4. 在队列元素为空的情况下，element() 方法会抛出NoSuchElementException异常，peek() 方法只会返回 null。
5. remove() 方法会抛出NoSuchElementException异常，

如图 因为测试用例中有个null值，所以不能用element(),它获取到null后就报异常了。
所以我们用remove把它移走，不放入set中，然后继续往下判断

假装我是个图
[5,3,6,2,4,null,7]
9

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean findTarget(TreeNode root, int k) {
        Set<Integer> set = new HashSet<>();
        Queue<TreeNode> queue = new LinkedList();
        queue.add(root);
        while(!queue.isEmpty()){
            if(queue.peek() != null){  //返回队列头元素
                TreeNode node = queue.remove(); 
                if(set.contains(k-node.val))
                    return true;
                set.add(node.val);
                queue.add(node.left);
                queue.add(node.right);
             }else
                queue.remove();//抛出异常 NoSuchElementException()  poll返回null
        }
        return false;
        
    }
}

方法三.使用 BST

中序遍历

• 中根序遍历
• 递归基本原理：左子树都遍历完了；存储自己本身的val;遍历右子树
• 所以是先对左边使用递归，存储自己的val,在对右边使用递归；
• 不要想着左子树的左右，因为基本原理也满足它；

时间复杂度：O(n) 遍历了整棵树，n
空间复杂度: O(n) list使用了n个空间

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean findTarget(TreeNode root, int k) {
        List <Integer> list = new ArrayList();
        inorder(root,list);
        //2个指针
        int l = 0;
        int r = list.size() - 1;
        while(l < r){//不能取到相等，以防自己加自己=k的情况
            if(list.get(l)< k - list.get(r)){
                l++;
            }else if(list.get(l)> k - list.get(r)){
                r--;
            }else{
                return true;
            }
        }
        return false;
    }
    public void inorder(TreeNode root,List<Integer> list){
        //中序遍历得到有序列表
        if(root!=null){
            inorder(root.left,list);
            list.add(root.val);
            inorder(root.right,list);
        }
    }
}