验证二叉搜索树

问题描述：

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

有效二叉树定义如下：

1. 节点的左子树只包含小于当前节点的数；

2. 节点的右子树只包含大于当前节点的数；

3. 所有左子树和右子树自身也必须是二叉搜素树

示例1：

输入： root = [2, 1, 3]

输出： true

示例2：

输入：root = [5, 1, 4, null, null, 3, 6]

输出： false

package main

import (
	"fmt"
)

type queue []*treeNode

func(q *queue) push(v *treeNode) {
	*q = append(*q, v)
}

func(q *queue) pop() *treeNode {
	tmp := *q
	if len(tmp) == 0 {
		return nil 
	}
	val := tmp[0]
	*q = tmp[1:]
	return val
}

func(q *queue) len() int {
	v := *q
	return len(v)
}

type treeNode struct {
	value int
	left  *treeNode
	right *treeNode
}

func arrToTree(arr []int) *treeNode {
	length := len(arr)
	q := make(queue, 0)
	j := 0
	root := &treeNode{
		value: arr[0],
	}
	q.push(root)
	var tree *treeNode
	for i := 1; i < length; i++ {
		if j == 0 {
			tree = q.pop()
			if arr[i] != -1 {
				tree.left = &treeNode{
					value: arr[i],
				}
				q.push(tree.left)
			}
		} else {
			if arr[i] != -1 {
				tree.right = &treeNode{
					value: arr[i],
				}
				q.push(tree.right)
			}
		}
		j++
		j = j % 2 
	}

	return root
}

func isBST(tree *treeNode) bool {
	if tree == nil {
		return true
	}

	if tree.left != nil {
		if tree.value < tree.left.value {
			return false
		}
		if !isBST(tree.left) {
			return false
		}
	}

	if tree.right != nil {
		if tree.value > tree.right.value {
			return false
		}
		if !isBST(tree.right) {
			return false
		}
	}
	return true
}

func main()  {
	// 默认-1为null
	tree1 := arrToTree([]int{2, 1, 3})
	fmt.Println("tree1 isBST", isBST(tree1))

	tree2 := arrToTree([]int{5, 1, 4, -1, -1, 3, 6})
	fmt.Println("tree1 isBST", isBST(tree2))
}