第一题-二叉搜索树中的搜索

题目

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。 你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null

思路

递归：从根节点开始遍历，根节点小于val，遍历左子树，大于val，遍历右子树，遇到根节点等于val，返回true，否则继续遍历，直到遍历到，根节点为null，返回false

代码

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        if(root == null) return root;
        if(root.val == val) {
            return root;
        }
        return root.val > val ? searchBST(root.left, val) : searchBST(root.right, val);
    }
}

第二题-二叉搜索树中的插入操作

题目

给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。 注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果

思路

自己的思路 1、定义一个节点，节点值为val，要作为节点插进树里

2、使用递归遍历树，节点值大于val，递归右子树，节点值小于val，递归左子树，遇到接单w为null插进去！！

官方题解，我觉得代码比我的简单哎，自己写的太垃圾

代码

class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        TreeNode insertNode = new TreeNode(val);
        if(root == null) {
            return insertNode;
        }
        TreeNode head = root;
        if(head.val > val) {
            if(head.left == null) {
                head.left = insertNode;
            }else {
                insertIntoBST(head.left, val);
            }
        }else {
            if(head.right == null) {
                head.right = insertNode;
            }else {
                insertIntoBST(head.right, val);
            }
        };
        return root;
    }
}

2、官方

class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        if (root == null) {
            return new TreeNode(val);
        }
        TreeNode pos = root;
        while (pos != null) {
            if (val < pos.val) {
                if (pos.left == null) {
                    pos.left = new TreeNode(val);
                    break;
                } else {
                    pos = pos.left;
                }
            } else {
                if (pos.right == null) {
                    pos.right = new TreeNode(val);
                    break;
                } else {
                    pos = pos.right;
                }
            }
        }
        return root;
    }
}

第三题-验证二叉搜索树

题目

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。 有效 二叉搜索树定义如下： 节点的左子树只包含 小于 当前节点的数。 节点的右子树只包含 大于 当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树

思路

1、原本按照思路，判断root是否大于left，并且root是否小于right，但是只做这个判断，会出现一种情况，右子树的左节点存在比根节点小的情况，左子树的右节点比根节点大的情况，所以需要额外定义一个值，作为对根节点的路，但是思路到这里我就卡住了，后来看了官方题解

2、官方题解：增加一个区间，判断子树中所有的节点是否都在区间中，判断左节点是否上限在upper之下，判断右节点下限是否在low之上

代码

class Solution {
    public boolean isValidBST(TreeNode root) {
        return check(root, Long.MIN_VALUE, Long.MAX_VALUE);
    }

    public static boolean check(TreeNode root, long low, long high) {
        if(root == null) {
            return true;
        }
        if(root.val >= high || root.val <= low) {
            return false;
        }
        return check(root.left, low, root.val) && check(root.right, root.val, high);
    }
}

第四题

题目

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先

思路

递归：找最近公共祖先，只要找到一个节点值在给定的两个数中间即可，否则继续遍历左子树/右子树

代码

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        int val = root.val;
        int pVal = p.val;
        int qVal = q.val;
        if((val >= pVal && val <= qVal) || (val <= pVal && val >= qVal)) {
            return root;
        }
        return val > pVal ? lowestCommonAncestor(root.left, p, q) : lowestCommonAncestor(root.right, p, q);
    }
}

第五题

题目

给定一个二叉搜索树 root 和一个目标结果 k，如果二叉搜索树中存在两个元素且它们的和等于给定的目标结果，则返回 true

思路

1、使用集合，递归遍历树，如果集合中存在目标值-val的值，返回true，否则继续遍历，直到root为null，返回false

2、双指针-官方题解： 二叉搜索树的中序遍历是升序排列的，我们可以将该二叉搜索树的中序遍历的结果记录下来，得到一个升序数组，该问题即转化为两数之和 II - 输入有序数组问题。我们可以使用双指针解决

代码

1、借助Set，递归遍历

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

2、双指针

class Solution {
    public boolean findTarget(TreeNode root, int k) {
        TreeNode left = root, right = root;
        Deque<TreeNode> leftStack = new ArrayDeque<TreeNode>();
        Deque<TreeNode> rightStack = new ArrayDeque<TreeNode>();
        leftStack.push(left);
        while (left.left != null) {
            leftStack.push(left.left);
            left = left.left;
        }
        rightStack.push(right);
        while (right.right != null) {
            rightStack.push(right.right);
            right = right.right;
        }
        while (left != right) {
            if (left.val + right.val == k) {
                return true;
            }
            if (left.val + right.val < k) {
                left = getLeft(leftStack);
            } else {
                right = getRight(rightStack);
            }
        }
        return false;
    }

    public TreeNode getLeft(Deque<TreeNode> stack) {
        TreeNode root = stack.pop();
        TreeNode node = root.right;
        while (node != null) {
            stack.push(node);
            node = node.left;
        }
        return root;
    }

    public TreeNode getRight(Deque<TreeNode> stack) {
        TreeNode root = stack.pop();
        TreeNode node = root.left;
        while (node != null) {
            stack.push(node);
            node = node.right;
        }
        return root;
    }
}