【代码随想录】算法训练计划20

1、654. 最大二叉树

题目：
给定一个不重复的整数数组 nums 。最大二叉树可以用下面的算法从 nums 递归地构建:
创建一个根节点，其值为 nums 中的最大值。
递归地在最大值左边的子数组前缀上构建左子树。
递归地在最大值右边的子数组后缀上构建右子树。
返回 nums 构建的最大二叉树。

思路：

简单，给节点遍历赋值

func constructMaximumBinaryTree(nums []int) *TreeNode {
    if len(nums) == 0 {
        return nil
    }
    index := findMax(nums)
    root := &TreeNode{
        Val: nums[index],
        Left: constructMaximumBinaryTree(nums[:index]),
        Right: constructMaximumBinaryTree(nums[index+1:]),
    }
    return root
}
func findMax(nums []int) int {
    max := 0
    index := 0
    for i:=0; i<len(nums);i++ {
        if nums[i] > max {
            index = i
            max = nums[i]
        }
    }
    return index
}

2、617. 合并二叉树

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

思路：

递归简单

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
}

3、700. 二叉搜索树中的搜索

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

思路：

自带排序

func searchBST(root *TreeNode, val int) *TreeNode {
    // 代码一刷，递归，简单
    if root == nil || root.Val == val {
        return root
    }
    if root.Val > val {
        return searchBST(root.Left, val)
    }
    return searchBST(root.Right, val)
}

4、98. 验证二叉搜索树

题目：
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。
有效二叉搜索树定义如下：
节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

思路：

条件就是搜索二叉树的特性

func isValidBST(root *TreeNode) bool {
    // 递归，代码一刷，中序遍历，直接判断
    if root == nil {
        return true
    }
    return check(root, math.MinInt64, math.MaxInt64)
}
func check(node *TreeNode, min,max int64) bool {
    if node == nil {
        return true
    }
    if int64(node.Val) <= min || int64(node.Val) >= max {
        return false
    }
    return check(node.Left, min, int64(node.Val)) && check(node.Right, int64(node.Val), max)
}