二叉搜索树的搜索/插入/删除/转换

验证是否是
此处要注意⚠️左子树和右子树中都不存在和节点相同的值，故为>=和<=

var isValidBST = function(root) {
    function dfs(root,min,max){
        if(!root) return true
        if(root.val<=min||root.val>=max){
            return false
        }
        return dfs(root.left,min,root.val)&&dfs(root.right,root.val,max)
    }
    return dfs(root,-Infinity,Infinity)
};

搜索节点

var searchBST = function(root, val) {
    if(!root) return null
    return findRoot(root,val)
};
function findRoot(root,val){
    if(!root) return null
    if(root.val===val){
        return root
    }
    if(root.val<val){
        return findRoot(root.right,val)
    }
    if(root.val>val){
        return findRoot(root.left,val)
    }
}

插入
一直向下探索，直到找到一个合适的空位可以插入新节点

var insertIntoBST = function(root, val) {
    if(!root){
       root=new TreeNode(val)
       return root
    }
    if(root.val>val){
        root.left=insertIntoBST(root.left,val)
    }else{
        root.right=insertIntoBST(root.right,val)
    }
    return root
};

删除

var deleteNode = function(root, key) {
    if(!root) return root
    if(root.val>key){
        root.left = deleteNode(root.left,key)
    }else if(root.val<key){
        root.right = deleteNode(root.right,key)
    }else{
        if(!root.left&&!root.right){
            root=null
        }else if(root.left){
            let maxVal=findMax(root.left)
            root.val=maxVal.val
            root.left=deleteNode(root.left,maxVal.val)
        }else{
            let minVal=findMin(root.right)
            root.val=minVal.val
            root.right=deleteNode(root.right,minVal.val)
        }
    }
    return root
};
function findMax(root){
    while(root.right){
        root=root.right
    }
    return root
}
function findMin(root){
    while(root.left){
        root=root.left
    }
    return root
}

有序数组转换为二叉搜索树
这题要注意⚠️的是：当在buildTree中递归时，在low>high要及时中止递归

var sortedArrayToBST = function(nums) {
    if(nums.length===0) return null
    const root=buildTree(0,nums.length-1)
    function buildTree(low,high){
        if(low>high){
            return null
        }
        const mid=Math.floor(low+(high-low)/2)
        const curr=new TreeNode(nums[mid])
        curr.left=buildTree(low,mid-1)
        curr.right=buildTree(mid+1,high)
        return curr
    }
    return root
};

判断是否是二叉搜索树的后序遍历
这里的递归终止位置是数组不存在/数组长度为0

var verifyPostorder = function(postorder) {
    function verify(order){
        if(order&&order.length>0){
            const root=order[order.length-1]
            for(var i=0;i<order.length-1;i++){
                if(order[i]>root){
                    break
                }
            }
            for(let j=i;j<order.length-1;j++){
                if(order[j]<root){
                    return false
                }
            }
            return verify(order.slice(0,i))&&verify(order.slice(i,order.length-1))   
        }else{
            return true
        }
    }
    return verify(postorder)
};