搜索二叉树的判断

搜索二叉树的判断

比较常见的面试题。

搜索二叉树

概念不说了，相信各位同学都是知道的，不知道的Google一下。

思路1

起初看到这个题，本来想着直接找递归公式，递归的判断，尝试了一下。发现不行。把尝试的代码贴出来吧。

func isValidBST(root *TreeNode) bool {
    return middleTranversal(root)
}

func middleTranversal(root *TreeNode) bool {
    if root == nil {
        return true
    }
    
    rl := middleTranversal(root.Left)
    rr := middleTranversal(root.Right)
    
    if !(rl && rr) {
        return false
    }
    
    ret := true
    if root.Left != nil {
        ret = root.Val > root.Left.Val
    }
    
    if root.Right != nil {
        ret = ret && (root.Val < root.Right.Val)
    }
    
    return ret
}

如果你看过这个代码，同学们应该看出来问题了，这个没有ac的原因在于递归公式漏了一个条件，没有考虑左子树中的所有值都小于根节点，右子树的所有值都大于根节点。这样一来似乎更麻烦了。

思路2

一提到搜索二叉树，有一个重要的特征不得不提，搜索二叉树的中序遍历时一个递增的序列或者是一个空序列。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */

// 中序遍历将节点值存储到slice中
func middleTranversal(root *TreeNode, slice []int) []int {
    if root == nil {
        return slice
    }
    
    slice = middleTranversal(root.Left, slice)
    slice = append(slice, root.Val)
    slice = middleTranversal(root.Right, slice)
    
    return slice
} 

// 中序遍历判断slice是否为递增序列
func isValidBST(root *TreeNode) bool {
    slice := []int{}
    
    slice = middleTranversal(root, slice)
    if len(slice) < 1 {
        return true
    }
    
    min := slice[0]
    for _, val := range slice[1:] {
        if val > min {
            min = val
            continue
        }
        
        return false
    }
    
    return true
}

上述的代码是用一个切片保存中序遍历的结果，然后在单独堆切片做一次判断，判断是否递增。其实也可以使用O(N)的空间复杂度，可以达到O(lgn),那就是在递归的过程中只使用一个变量。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
const INT_MAX = int(^uint(0) >> 1)
const INT_MIN = ^INT_MAX

func isValidBST(root *TreeNode) bool {
    var tem int = INT_MIN
    
    return middleTranversal(root, &tem)
}

func middleTranversal(root *TreeNode, tem *int) bool {
    if root == nil {
        return true
    }
    
    rl := middleTranversal(root.Left, tem)
    
    if root.Val <= *tem {
        return false
    }
    *tem = root.Val
    
    rr := middleTranversal(root.Right, tem)
    
    
    return rl && rr
}

其实可以达到O(1)的空间复杂度，可以使用Morris遍历。但是由于还没说Morris遍历，所以不陈述了，有兴趣的可以查阅相关遍历算法。

关于作者

大四学生一枚，分析数据结构，面试题，golang，C语言等知识。QQ交流群：521625004。微信公众号：后台技术栈。