二叉搜索树的基本操作汇总

一、什么是二叉搜索树？

对于其每个结点K，其左子树都小于K的值，右子树都大于K的值

可以得出一个性质：
——如果一个二叉树的中序遍历是单调递增的，那么它就是二叉搜索树！

二、验证是否为二叉搜索树

（1）用递归法进行中序遍历，用Arrayist来判断是否递增：

class Solution {
    public boolean isValidBST(TreeNode root) {
        if(root == null) return true;
        List<Integer> list = new ArrayList<>();
        dfs(root,list);
        int len = list.size();
        for(int i=1;i<len;i++){//判断是否为递增
            if(list.get(i)<=list.get(i-1)){//左节点值必须小于父节点值，不可以等于
                return false;
            }
        }
        return true;
    }
    //中序遍历
    public void dfs(TreeNode root,List<Integer> list){
        if(root == null) return;
        dfs(root.left,list);
        list.add(root.val);
        dfs(root.right,list);
    }
}

（2）中序遍历（非递归法），看它是不是单调递增的：

class Solution {
    public boolean isValidBST(TreeNode root) {
       Stack<TreeNode> stack = new Stack<>();
       //代表中序遍历输出的结点值，在第一个的前面，需要尽量小
       double inorder = -Double.MAX_VALUE;

       TreeNode cur = root;
       while(cur != null || !stack.isEmpty()){
           if(cur != null){
               stack.push(cur);
               cur = cur.left;
           }else{
               cur = stack.pop();//中序遍历得到的结点，从前往后
               //inorder表示前一个中序遍历输出结点值，后面的必须比前面的大
               if(cur.val <= inorder) return false;
               inorder = cur.val;//用inorder表示当前中序遍历输出值
               cur = cur.right;///若还未到达父结点，则curr.right=null，继续循环
           }
       }
       return true;
    }

}

三、二叉搜索树的查找

/* 查找以t为根节点的树中，是否包含x */
Position Find(int x, SearchTree t)
{
    if (t == NULL) {
        return NULL;
    } else if (x < t.val) {
        return Find(x, t.left);
    } else if (x > t.val) {
        return Find(x, t.right);
    } else {
        return t;
    }
}

四、【二叉搜索树】就地转【单链表结构】

原题地址
二叉树数据结构TreeNode可用来表示单向链表（其中left置空，right为下一个链表节点）。实现一个方法，把二叉搜索树转换为单向链表，要求值的顺序保持不变，转换操作应是原址的，也就是在原始的二叉搜索树上直接修改。
返回转换后的单向链表的头节点。

class Solution {
    TreeNode f = new TreeNode(-1);
    public TreeNode convertBiNode(TreeNode root) {
        TreeNode  tmp = f;
        dfs(root);
        return tmp.right;
    }
    //中序遍历并原地修改原二叉树
    public void dfs(TreeNode root){
        if(root==null) return;
        dfs(root.left);
        f.right = root;
        root.left = null;//原地修改
        f = f.right;
        dfs(root.right);
    }
}

五、有序链表/数组 转 高度平衡二叉搜索树

5.1 有序链表

给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。
本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        return buildTree(head,null);//当head也为null，返回null
    }
    //分治思想
    public TreeNode buildTree(ListNode left,ListNode right){
        if(left == right){
            return null;
        }
        ListNode mid = getMid(left,right);
        TreeNode root = new TreeNode(mid.val);
        root.left = buildTree(left,mid);
        root.right = buildTree(mid.next,right);
        return root;
    }
	//找出链表中间节点
    public ListNode getMid(ListNode left,ListNode right){
        ListNode fast = left;
        ListNode slow = left;
        while(fast != right && fast.next != right){//得排除只有两个结点的情况
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }
}

5.2 有序数组

将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。

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

    public TreeNode bulidTree(int[] nums,int left,int right){
        if(left > right) {
            return null;
        }
        int mid = (left + right) / 2;//判断中点
        TreeNode root = new TreeNode(nums[mid]);
        root.left = bulidTree(nums,left,mid-1);
        root.right = bulidTree(nums,mid+1,right);
        return root;
    }
}

六、1~n所有二叉搜索树

5.1 求种数

给定一个整数 n，求以 1 … n 为节点组成的二叉搜索树有多少种？

class Solution {
    public int numTrees(int n) {
        int[] dp = new int[n+1];
        dp[0] = 1;
        dp[1] = 1;
        
        for(int i=2;i<n+1;i++){
            for(int j=1;j<i+1;j++){
                dp[i] = dp[i] + dp[j-1] * dp[i-j];
            }
        }
        return dp[n];
    }
}

5.2 输出所有可能的二叉搜索树

给定一个整数 n，生成所有由 1 … n 为节点所组成的 二叉搜索树 。题目来源：LeetCode95

class Solution {
    public List<TreeNode> generateTrees(int n) {
        if(n==0) return new ArrayList<>();
        return dfs(1,n);
    }
    private List<TreeNode> dfs(int l,int r){
        List<TreeNode> res=new ArrayList<>();
        if(l>r){
            res.add(null);
            return res;
        }
        //枚举根节点
        for(int i=l;i<=r;i++){
            //根节点为i，此时左子树为 l~i-1
           List<TreeNode>left=dfs(l,i-1);
            //右子树为i+1~r
            List<TreeNode>right=dfs(i+1,r);
            for(TreeNode lh:left){
                for(TreeNode rh:right){
                    TreeNode root=new TreeNode(i);
                    root.left=lh;
                    root.right=rh;
                    res.add(root);
                }
            }
        }
        return res;
    }
}