题目描述
给定一个二叉搜索树的 根节点 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;
}
}
因为我们要从两头遍历,所以用两个栈,两个指针,反中序遍历的操作和中序遍历操作反过来就可以了。