算法训练第15天|654.最大二叉树|617.合并二叉树|700.二叉搜索树中的搜索|98.验证二叉搜索树

LeetCode 654.最大二叉树

题目链接：654.最大二叉树

题目讲解：代码随想录

题目描述：给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:

1. 创建一个根节点，其值为 nums 中的最大值。
2. 递归地在最大值 左边 的 子数组前缀上 构建左子树。
3. 递归地在最大值 右边 的 子数组后缀上 构建右子树。

返回 nums 构建的 最大二叉树 。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func constructMaximumBinaryTree(nums []int) *TreeNode {

    if len(nums) == 0{
        return nil
    }
    
    max := nums[0]
    index := 0

    // 找到最大值
    for i := 0; i < len(nums); i++{
        if nums[i] > max{
            max = nums[i]
            index = i
        }
    }

    root := &TreeNode{Val: max}

    left := nums[:index]
    right := nums[index+1:]

    root.Left = constructMaximumBinaryTree(left)
    root.Right = constructMaximumBinaryTree(right)

    return root
}

LeetCode 617.合并二叉树

题目链接：617.合并二叉树

题目讲解：代码随想录

题目描述：给你两棵二叉树： root1 和 root2 。想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。注意: 合并过程必须从两个树的根节点开始。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func mergeTrees(root1 *TreeNode, root2 *TreeNode) *TreeNode {
    if root1 == nil{
        return root2
    }

    if root2 == nil{
        return root1
    }

    root1.Val += root2.Val
    root1.Left = mergeTrees(root1.Left, root2.Left)
    root1.Right = mergeTrees(root1.Right, root2.Right)
    return root1
}

LeetCode 700.二叉搜索树中的搜索

题目链接：700.二叉搜索树中的搜索

题目讲解：代码随想录

题目描述：给定二叉搜索树（BST）的根节点 root 和一个整数值 val。你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

 使用层序遍历：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func searchBST(root *TreeNode, val int) *TreeNode {
    if root == nil{
        return nil
    }

    curLevel := []*TreeNode{root}

    for len(curLevel) > 0{
        nextLevel := []*TreeNode{}

        for _, node := range curLevel{
            if node.Val == val{
                return node
            }

            if node.Left != nil{
                nextLevel = append(nextLevel, node.Left)
            }

            if node.Right != nil{
                nextLevel = append(nextLevel, node.Right)
            }
        }
        curLevel = nextLevel
    }
    return nil
}

LeetCode 98.验证二叉搜索树

题目链接：98.验证二叉搜索树

题目讲解：代码随想录

题目描述：给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

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

 二叉搜索树的中序遍历是一个顺序数组，所以利用这个做这道题目。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isValidBST(root *TreeNode) bool {
    // 保存上一个指针
    var prev *TreeNode
    var travel func(node *TreeNode) bool
    travel = func(node *TreeNode) bool{
        if node == nil{
            return true
        }

        leftRes := travel(node.Left)
        // 当前值小于等于前一个节点的值，返回false
        if prev != nil && node.Val <= prev.Val{
            return false
        }
        prev = node
        rightRes := travel(node.Right)
        return leftRes && rightRes
    }
    return travel(root)
}