Day20 Golang （二叉树）654.最大二叉树 617.合并二叉树 700.二叉搜索树中的搜索 98.验证二叉搜索树

// 654.最大二叉树

package main

import "fmt"

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func constructMaximumBinaryTree(nums []int) *TreeNode {
	//终止条件
	if len(nums) == 0 {
		return nil
	}
	//找到最大值的下标
	index := maxValue(nums)
	//构造二叉树
	root := &TreeNode{
		Val:   nums[index],
		Left:  constructMaximumBinaryTree(nums[:index]),
		Right: constructMaximumBinaryTree(nums[index+1:]),
	}
	return root

}
func maxValue(nums []int) int {
	index := 0
	for i, v := range nums {
		if v > nums[index] {
			index = i
		}
	}
	return index
}
func main() {
	array := []int{3, 2, 1, 6, 0, 5}
	res := constructMaximumBinaryTree(array)
	fmt.Printf("res: %v\n", res) //res: &{6 0xc0000080a8 0xc0000080d8}
}

// 617.合并二叉树

package main

import "fmt"

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
}

func main() {
	//k=3
	node1, node2, node3, node4 := TreeNode{1, nil, nil}, TreeNode{2, nil, nil}, TreeNode{7, nil, nil}, TreeNode{8, nil, nil}
	//k=2
	node5, node6 := TreeNode{4, &node1, &node2}, TreeNode{6, &node3, &node4}
	//k=1
	node7 := TreeNode{5, &node5, &node6}

	//k=3
	node11, node22, node33, node44 := TreeNode{1, nil, nil}, TreeNode{2, nil, nil}, TreeNode{7, nil, nil}, TreeNode{8, nil, nil}
	//k=2
	node55, node66 := TreeNode{4, &node11, &node22}, TreeNode{6, &node33, &node44}
	//k=1
	node77 := TreeNode{5, &node55, &node66}
	res := mergeTrees(&node7, &node77)
	fmt.Printf("res: %v\n", res)//res: &{10 0xc0000080d8 0xc0000080f0}
}

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

package main

import "fmt"

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func searchBST(root *TreeNode, val int) *TreeNode {
	//二叉搜索树 左<中<右
	//迭代法
	for root != nil {
		if val > root.Val {
			root = root.Right
		} else if val < root.Val {
			root = root.Left
		} else {
			return root
		}
	}
	return nil
}
func main() {
	//k=3
	node1, node2, node3, node4 := TreeNode{1, nil, nil}, TreeNode{2, nil, nil}, TreeNode{7, nil, nil}, TreeNode{8, nil, nil}
	//k=2
	node5, node6 := TreeNode{4, &node1, &node2}, TreeNode{6, &node3, &node4}
	//k=1
	node7 := TreeNode{5, &node5, &node6}
	res := searchBST(&node7, 8)
	fmt.Printf("res.Val: %v\n", res.Val) //res.Val: 8
}

//98.验证二叉搜索树

package main

import "fmt"

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func isValidBST(root *TreeNode) bool {
	//核心：中序遍历是有序数组
	var pre *TreeNode
	var isValid func(root *TreeNode) bool
	isValid = func(root *TreeNode) bool {
		// 终止条件
		if root == nil {
			return true
		}
		//左
		left := isValid(root.Left)
		//中
		if pre != nil && pre.Val >= root.Val { //注意这里是大于等于，包含结点元素相等的情况
			return false
		}
		pre = root
		//右
		right := isValid(root.Right)
		return left && right
	}
	res := isValid(root)
	return res
}

func main() {
	//k=3
	node1, node2, node3, node4 := TreeNode{1, nil, nil}, TreeNode{2, nil, nil}, TreeNode{7, nil, nil}, TreeNode{8, nil, nil}
	//k=2
	node5, node6 := TreeNode{4, &node1, &node2}, TreeNode{6, &node3, &node4}
	//k=1
	node7 := TreeNode{5, &node5, &node6}
	res := isValidBST(&node7)
	fmt.Printf("res: %v\n", res) //res: false
}