二叉搜索树

700.二叉搜索树中的搜索

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

例如，

在上述示例中，如果要找的值是 5，但因为没有节点值为 5，我们应该返回 NULL。

 

 public TreeNode searchBST(TreeNode root, int val) {
        return search(root,val);

    }
    private TreeNode search(TreeNode root,int val){
        if(root==null){
            return null;
        }
 
        if(val>root.val){
           return search(root.right,val);
        }
        if(val<root.val){
            return search(root.left,val);
        }
        return root;
    }

 

98. 验证二叉搜索树

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

• 节点的左子树只包含小于当前节点的数。
• 节点的右子树只包含大于当前节点的数。
• 所有左子树和右子树自身必须也是二叉搜索树。

　

 public boolean isValidBST(TreeNode root) {
      return process(root).isBST;
    }

    // max ,min left.isbst right.isbst left.max<root.val right.min>root.val
    private Info process(TreeNode root){
        if(root ==null){
            return null;// 注意这里，设为空就好，因为最大值和最小值不好设置，会超限的情况，不好控制，后面用时判空就好
        }
   
        Info left=process(root.left);
        Info right=process(root.right);
        int min=root.val;
        int max=root.val;
        
        if(left!=null){
            min=Math.min(left.min,min);
            max=Math.max(left.max,max);
        }
        if(right!=null){
            min=Math.min(right.min,min);
            max=Math.max(right.max,max);
        }
        boolean isBST=false;
        boolean leftFlag=left==null?true:left.isBST && left.max<root.val;
        boolean rightFlag=right==null?true:right.isBST && right.min>root.val;
        if(leftFlag && rightFlag){
            isBST=true;
        }
        return new Info(max,min,isBST);
    }

    public class Info{
        int max;
        int min;
        boolean isBST;
        public Info(int max,int min,boolean isBST){
            this.max=max;
            this.min=min;
            this.isBST=isBST;
        }
    }

　　

 

530.二叉搜索树的最小绝对差

给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。

示例：

提示：树中至少有 2 个节点。

思路

题目中要求在二叉搜索树上任意两节点的差的绝对值的最小值。

注意是二叉搜索树，二叉搜索树可是有序的。

遇到在二叉搜索树上求什么最值啊，差值之类的，就把它想成在一个有序数组上求最值，求差值，这样就简单多了。

递归

那么二叉搜索树采用中序遍历，其实就是一个有序数组。

在一个有序数组上求两个数最小差值。

最直观的想法，就是把二叉搜索树转换成有序数组，然后遍历一遍数组，就统计出来最小差值了

 

 遇到在二叉搜索树上求什么最值，求差值之类的，都要思考一下二叉搜索树可是有序的，要利用好这一特点。

class Solution {
    int minDiff=Integer.MAX_VALUE;
    TreeNode pre=null;
   
    public int getMinimumDifference(TreeNode root) {
         getMinDiff(root);
         return minDiff;
    }

    private void getMinDiff(TreeNode root){
        if(root==null){
            return;
        }
        getMinDiff(root.left);
        if(pre!=null){
            minDiff=Math.min(minDiff,Math.abs(pre.val-root.val));
        }

        pre=root;
        getMinDiff(root.right);
    
    }
}

　　

 

701. 二叉搜索树中的插入操作

给定二叉搜索树（BST）的根节点和要插入树中的值，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。

注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。

 

示例 1：

 

 

 

public TreeNode insertIntoBST(TreeNode root, int val) {
        return insert(root,val);
    }

    public TreeNode insert(TreeNode root,int val){
        if(root==null){
            return new TreeNode(val);
        }
        TreeNode cur=root;
        TreeNode pre=null;
        while(cur!=null){
             pre=cur;
            if(val>cur.val){
                cur=cur.right;
            }else {
                cur=cur.left;
            }
        }

        if(val>pre.val){
            pre.right=new TreeNode(val);
        }else{
            pre.left=new TreeNode(val);
        }
        return root;
    }

　

450. 删除二叉搜索树中的节点

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

一般来说，删除节点可分为两个步骤：

首先找到需要删除的节点；
如果找到了，删除它。
说明： 要求算法时间复杂度为 O(h)，h 为树的高度。

示例:

root = [5,3,6,2,4,null,7]
key = 3

5
/ \
3 6
/ \ \
2 4 7

 public TreeNode deleteNode(TreeNode root, int key) {
        return delete(root,key);
    }

    private TreeNode delete(TreeNode root,int key){
        if(root==null){
            return root;
        }
        TreeNode cur=root;
        if(key>cur.val){
            cur.right=delete(cur.right,key);//理解一下这里
        }else if(key<cur.val){
            cur.left=delete(cur.left,key);
        }else{
            if(cur.left==null && cur.right==null){
                cur=null;
            }else if(cur.left==null && cur.right!=null){
                cur=cur.right;
            }else if(cur.right==null && cur.left!=null){
                cur=cur.left;
            }else{
                TreeNode des=cur.right;
                TreeNode pre=null;
                while(des.left!=null){
                    pre=des;
                    des=des.left;
                }
                if(pre!=null){
                    pre.left=des.right;
                    des.right=cur.right;
                }
                des.left=cur.left;
                cur=des;
                
            }
        }
        return cur;
    }

　　

108. 将有序数组转换为二叉搜索树

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

 

示例 1：

输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

public TreeNode sortedArrayToBST(int[] nums) {
        if(nums==null || nums.length==0){
            return null;
        }
        return sortTree(nums,0,nums.length-1);
    }

    private TreeNode sortTree(int[] nums,int L,int R){
        if(L>R){
            return null;
        }
        int M=L+((R-L)>>1);
        TreeNode root=new TreeNode(nums[M]);
        root.left=sortTree(nums,L,M-1);
        root.right=sortTree(nums,M+1,R);
        return root;
    }