Day 17|● 654.最大二叉树 ● 617.合并二叉树 ● 700.二叉搜索树中的搜索 ● 98.验证二叉搜索树

654.最大二叉树

最大二叉树
第一次用闭包函数尝试做了，主要是对于返回值部分把握的不好

func constructMaximumBinaryTree(nums []int) *TreeNode {
    

    var build func([]int) *TreeNode

    build = func(nums []int) *TreeNode{
        if len(nums) == 0{
            return nil
        }
        MaxIndex := 0
        for i := 0; i < len(nums); i++{
            if nums[MaxIndex] < nums[i]{
                MaxIndex = i
            }
        }
        Lnums := nums[:MaxIndex]
        Rnums := nums[MaxIndex + 1 :]

        root := &TreeNode{Val:nums[MaxIndex]}
        root.Left = build(Lnums)
        root.Right = build(Rnums)
        return root
    }

    return build(nums)    

}

617.合并二叉树

合并二叉树
主要是需要注意一棵树已经是nil时不能停，当两棵树全部nil才可以停下来

func mergeTrees(root1 *TreeNode, root2 *TreeNode) *TreeNode {
    var build func(*TreeNode,  *TreeNode) *TreeNode

    build = func(node1 *TreeNode, node2 *TreeNode) *TreeNode{
        if node1 == nil && node2 == nil{
            return nil
        }
        var nodeVal int
        if node1 == nil{
            nodeVal = node2.Val
        }else if node2 == nil{
            nodeVal = node1.Val
        }else{
            nodeVal = node1.Val + node2.Val
        }

        root := &TreeNode{Val: nodeVal}
        if node1 == nil{
            root.Left = build(nil, node2.Left)
            root.Right = build(nil,node2.Right)
        }else if node2 == nil{
            root.Left = build(node1.Left, nil)
            root.Right = build(node1.Right, nil)
        }else{
            root.Left = build(node1.Left, node2.Left)
            root.Right = build(node1.Right, node2.Right)
        }
        return root
    }
    return build(root1, root2)
}

700.二叉搜索树中的搜索

二叉搜索树中的搜索
返回的时根节点，所以闭包函数的返回值要设定成根节点

func searchBST(root *TreeNode, val int) *TreeNode {
    var bulid func(*TreeNode) *TreeNode


    bulid = func(node *TreeNode) *TreeNode{
        if node == nil {return nil}
        if node.Val == val{return node}
        var Rbool , Lbool *TreeNode
        Rbool = nil
        Lbool = nil
        if val > node.Val{
            Rbool = bulid(node.Right)
        }else{
            Lbool = bulid(node.Left)
        }
        if Rbool != nil{
            return Rbool
        }
        return Lbool
    }
    return bulid(root)

}

98.验证二叉搜索树

验证二叉搜索树
如果没有下图这种情况的话其实这需要从上往下判断父节点是否在两个子节点之间就好了。但是可能会出现这种隔着几层有一个错值的情况，所以还是用最大值和最小值来约束比较好。

func isValidBST(root *TreeNode) bool {
    var build func(*TreeNode, int, int) bool
 
    build = func(node *TreeNode,maxNum, minNum int) bool {
        if node == nil {return true}
        if node.Val >= maxNum || node.Val <= minNum{
            return false
        }
        Lbool := build(node.Left, node.Val,minNum)
        Rbool := build(node.Right, maxNum, node.Val)

        return Lbool && Rbool
    }
    return build(root, math.MaxInt64, math.MinInt64)
}