二叉搜索树中两个节点之和（剑指offer-56）

原题链接

题目描述

给定一个二叉搜索树的 根节点 root 和一个整数 k , 请判断该二叉搜索树中是否存在两个节点它们的值之和等于 k 。假设二叉搜索树中节点的值均唯一。

示例1

输入: root = [8,6,10,5,7,9,11], k = 12
输出: true
解释: 节点 5 和节点 7 之和等于 12

示例2

输入: root = [8,6,10,5,7,9,11], k = 22
输出: false
解释: 不存在两个节点值之和为 22 的节点

思路1

栈 + 哈希表。哈希表里存放遍历过的结点的值，每遍历一个结点cur，判断哈希表中是否存在k-cur.val，如果存在那么直接返回true，否则就把cur.val存入哈希表。当遍历完所有结点还没有返回true的话，说明没有相加等于k的两节点，返回false

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean findTarget(TreeNode root, int k) {
        Stack<TreeNode> st = new Stack();
        Map<Integer, Integer> map = new HashMap();
        TreeNode cur = root;
        while(cur != null || !st.empty()){
            while(cur != null){
                st.push(cur);
                cur = cur.left;
            }
            cur = st.pop();
            if(map.containsKey(k - cur.val)){
                return true;
            }
            map.put(cur.val, 1);
            cur = cur.right;
        }
        return false;
    }
}

思路2

既然求二叉搜索树结点两数之和，可以联想到LeetCode第一题两数之和。

原题链接

求数组中（有序数组）的两数之和我们用的是双指针，指针left指向最小的数，指针right指向最大的数，如果left + right == k，返回true；如果left + right < k，则left指向更大的数；如果left + right > k，则right指向更小的数。
如果left和right相遇时还没有返回true，那么说明不存在相加等于k的数，返回false。

同样，在二叉搜索树中我们依然可以用这个方法（二叉搜索树的中序遍历也是有序的）。只是区别在于，一个遍历的是数组，一个遍历的是树。

我们依然可以设两个指针，左指针指向二叉搜索树中最小的结点（最左下角），右指针指向二叉搜索树中最大的结点（最右下角）。
我们可以写一个遍历树的迭代器类，迭代器里面有两个方法，一个获得左指针的下一个结点，即比当前左指针大的节点中最小的一个；一个获得右指针的下一个结点，即比当前右指针小的节点中最大的一个。

先上代码，细节下面说。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean findTarget(TreeNode root, int k) {
        BSTIterator interator = new BSTIterator(root);
        int left = interator.getLeftNext();
        int right = interator.getRightNext();
        while(left < right){
            if(left + right == k){
                return true;
            }else if(left + right < k){
                left = interator.getLeftNext();
            }else{
                right = interator.getRightNext();
            }
        }
        return false;
    }

    private class BSTIterator {
        Stack<TreeNode> lst, rst;
        TreeNode lcur, rcur;

        public BSTIterator(TreeNode root) {
            lst = new Stack();
            rst = new Stack();
            lcur = root;
            rcur = root;
        }

		//中序遍历
        public int getLeftNext(){
            while(lcur != null){
                lst.push(lcur);
                lcur = lcur.left;
            }
            lcur = lst.pop();
            int val = lcur.val;
            lcur = lcur.right;
            return val;
        }
        
        //反中序遍历
        public int getRightNext(){   
            while(rcur != null){
                rst.push(rcur);
                rcur = rcur.right;
            }
            rcur = rst.pop();
            int val = rcur.val;
            rcur = rcur.left;
            return val;
        }   
    
    }
}

这个迭代器类就是在中序遍历的基础上改造的

//中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList();
        Stack<TreeNode> st = new Stack();
        TreeNode cur = root;
        while(cur != null || !st.empty()){
            while(cur != null){
                st.push(cur);
                cur = cur.left;
            }
            cur = st.pop();
            list.add(cur.val);
            cur = cur.right;
        }
        return list;
    }

}

因为我们要从两头遍历，所以用两个栈，两个指针，反中序遍历的操作和中序遍历操作反过来就可以了。