树-BST（二叉搜索树）

class Solution {
    public TreeNode trimBST(TreeNode root, int low, int high) {
        if(root == null){
            return root;
        }
        //当根节点值大于最大值，直接返回修剪过的左节点
        if(root.val>high){
            return trimBST(root.left,low,high);
        }
        //当根节点值小于最小值，直接返回修剪过的右节点
        if(root.val<low){
            return trimBST(root.right,low,high);
        }
        //如果节点值在范围内，遍历节点的左右节点
        root.left = trimBST(root.left,low,high);
        root.right = trimBST(root.right,low,high);
        return root;
    }
}

 

---

二叉搜索树中的中序遍历有特殊含义，即如果按中序遍历二叉搜索树的话，是从小往大遍历的

class Solution {
    //记录当前的值
    int val = 0;
    //代表第几个树
    int kp = 0;
    public int kthSmallest(TreeNode root, int k) {
        if(root==null){
            return 0;
        }
        //左
        kthSmallest(root.left,k);
        //对节点的操作，因为二叉排序树中序遍历是从小到大排列，每遍历一个树kp++，当kp=k的时候，就是第几小的树
        kp++;
        if(kp==k){
            val=root.val;   
        }
        //右
        kthSmallest(root.right,k);

        return val;
    }
}

如果是中序遍历是 右 中 左 的话，则是从大到小遍历

class Solution {
    //记录当前的值
    int val = 0;
    //代表第几个树
    int kp = 0;
    public int kthSmallest(TreeNode root, int k) {
        if(root==null){
            return 0;
        }

        //右
       kthSmallest(root.right,k);

        //对节点的操作
        kp++;
        if(kp==k){
            val=root.val;   
        }

        //左
         kthSmallest(root.left,k);
        
        return val;
    }
}

---

递归做法

 

class Solution {
    int sum = 0;
    
    public TreeNode convertBST(TreeNode root) {
        order(root);
        return root;
        }
    public void order(TreeNode root){
        if(root==null){
            return;
        }
        //遍历右子树
        order(root.right);
        //累加
        sum+=root.val;
        root.val=sum;
        //遍历左子树
        order(root.left);
    }
    
}

因为要加比当前节点大的，所以要加上所有的右节点

 

 

class Solution {
    
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        //p和q的值均小于当前节点值，以左节点为根，继续寻找
       if(root.val>p.val&&root.val>q.val){
           return lowestCommonAncestor(root.left,p,q);
       }
       //p和q的值均大于当前节点值，以右节点为根，继续寻找
       if(root.val<p.val&&root.val<q.val){
           return lowestCommonAncestor(root.right,p,q);
       }
       //满足条件
       return root;
    }
}