【二叉树系列】验证二叉搜索树&二叉搜索树的最小绝对差&二叉搜索树中的众数&二叉树的最近公共祖先

验证二叉搜索树

//98. 验证二叉搜索树
func isValidBST(root *TreeNode) bool {
  return isValidBSTV1(root,math.MinInt8,math.MaxInt8)
}
func isValidBSTV1(root *TreeNode,min,max int) bool {
  if root==nil{
    return true
  }
  if min>=root.Val || root.Val>=max {
    return false
  }
  return isValidBSTV1(root.Left,min,root.Val) &&
    isValidBSTV1(root.Right,root.Val,max)
}

//98. 验证二叉搜索树
func isValidBSTV2(root *TreeNode) bool {
  var trace func(node *TreeNode) bool
  var pre *TreeNode
  trace= func(node *TreeNode) bool {
    if node==nil{
      return true
    }
    leftRes:=trace(node.Left)
    /*
    利用二叉搜索树的特性，左小于根，根大于右，利用中序遍历，则是左根右，恰好是升序遍历
    二叉树不能有重复节点，故等于也是false
    故前一个节点大于等于当前节点则 false
    */
    if pre!=nil && pre.Val>=node.Val{
      return false
    }
    pre=node
    rightRes:=trace(node.Right)
    return leftRes && rightRes
  }
  return trace(root)
}

二叉搜索树的最小绝对差

//二叉搜索树的最小绝对差
func getMinimumDifference(root *TreeNode) int {
  var arr []int
  traceTree(root,&arr)
  arrLen:=len(arr)
  val:=1000000
  fmt.Printf("arrLen:%d \n",arrLen)
  for i := 1; i < arrLen; i++ {
    temp:=arr[i]-arr[i-1]
    fmt.Printf("temp:%d,val:%d\n",temp,val)
    if val>temp{
      val=temp
    }
  }
  return val
}
func traceTree(root *TreeNode,arr *[]int){
  //递归中序遍历
  if root==nil{
    return
  }
  traceTree(root.Left,arr)
  *arr=append(*arr, root.Val)
  traceTree(root.Right,arr)
}

//二叉搜索树的最小绝对差
func getMinimumDifferenceV1(root *TreeNode) int {
  val:=1000000
  if root==nil{
    return val
  }
  lt:=list.New()
  cur:=root
  var arr []int
  for lt.Len()>0 || cur!=nil{
    if cur!=nil{
      lt.PushBack(cur)
      cur=cur.Left
    }else{
      node:=lt.Remove(lt.Back()).(*TreeNode)
      if node!=nil{
        arr=append(arr, node.Val)
        cur=node.Right
      }
    }
  }
  fmt.Printf("len arr:%d \n",len(arr))
  return val
}

 二叉搜索树中的众数

// 二叉搜索树中的众数
func findMode(root *TreeNode) []int {
  var arr []int
  var trace func(node *TreeNode)
  var pre *TreeNode
  count,maxVal:=1,1
  trace= func(node *TreeNode) {
    if node==nil{
      return
    }
    trace(node.Left)
    if pre!=nil && pre.Val==node.Val{
      count++
    }else{
      count=1
    }
    if count>=maxVal{
      fmt.Printf("count:%d,max:%d,arr:%v \n",count,maxVal,arr)
      if count>maxVal && len(arr)>0{
        arr=nil
        arr=append(arr, node.Val)
      }else{
        arr=append(arr, node.Val)
      }
      maxVal=count
    }
    pre=node
    trace(node.Right)
  }
  trace(root)
  return arr
}

236. 二叉树的最近公共祖先

//236. 二叉树的最近公共祖先
func lowestCommonAncestorV1(root, p, q *TreeNode) *TreeNode {
  if root==nil{
    return nil
  }
  lt:=list.New()
  lt.PushBack(root)
  var temp,temp1 *TreeNode
  for lt.Len()>0{
    node:=lt.Remove(lt.Front()).(*TreeNode)
    if node.Val==p.Val{
      temp=node.Left
    }
    if node.Left!=nil && node.Left.Val==p.Val && node.Right!=nil && node.Right.Val==q.Val{
      return root
    }else if node.Left!=nil && node.Left.Val==p.Val{
      lt.PushBack(node.Left)
      temp=node.Left
    }else if node.Right!=nil && node.Right.Val==q.Val{
      lt.PushBack(node.Right)
      temp1=node.Right
    }
  }
  if temp!=nil && temp1!=nil{
    return temp1
  }
  return temp
}

//236. 二叉树的最近公共祖先
func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
  if root==nil{
    return nil
  }
  if root==p || root==q {
    return  root
  }
  left:=lowestCommonAncestor(root.Left,p,q)
  right:=lowestCommonAncestor(root.Right,p,q)
  if left!=nil && right!=nil{
    return root
  }
  if left!=nil{
    return left
  }
  if right!=nil{
    return right
  }
  return nil
}