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

Posted 2022-06-19 liu_dudu

验证二叉搜索树

//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