二叉树系列【 从中序与后序遍历序列构造二叉树】【最大二叉树】【合并二叉树】【二叉搜索树中的搜索】

从中序与后序遍历序列构造二叉树

//106. 从中序与后序遍历序列构造二叉树
func buildTree(inorder []int, postorder []int) *TreeNode {
  if len(inorder)==0 || len(postorder)==0{
    return nil
  }
  ptL:=len(postorder)
  val:=postorder[ptL-1]
  index:=findInOrderIndex(inorder,val)
  fmt.Printf("index:%d,val:%d,inorder:%v,postorder:%v\n",index,val,inorder,postorder)
  root:=TreeNode{
    val,buildTree(inorder[:index],postorder[:index]),//重点：postorder[:index]的原因是：要确保中序和后序数组的长度一致
    buildTree(inorder[index+1:],postorder[index:ptL-1]),
  }
  return &root
}
func findInOrderIndex(inorder []int,val int) int  {
  for i,v := range inorder {
    if v==val{
      return  i
    }
  }
  return -1
}

最大二叉树

//654. 最大二叉树
func constructMaximumBinaryTree(nums []int) *TreeNode {
  if len(nums)<1{
    return nil
  }
  index:=findNumxMax(nums)
  root:=TreeNode{nums[index],
    constructMaximumBinaryTree(nums[:index]),
      constructMaximumBinaryTree(nums[index+1:])}
  return &root
}
func findNumxMax(inorder []int) (index int)  {
  for i := 1; i < len(inorder); i++ {
    if inorder[i]>inorder[index]{
      index=i
    }
  }
  return index
}

合并二叉树

//617. 合并二叉树
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
}
//617. 合并二叉树
func mergeTreesV1(root1 *TreeNode, root2 *TreeNode) *TreeNode {
  if root1==nil{
    return root2
  }
  if root2==nil{
    return root1
  }
  lt1:=list.New()
  lt1.PushBack(root1)
  lt2:=list.New()
  lt2.PushBack(root2)
  for lt1.Len()>0 || lt2.Len()>0{
    node1:=lt1.Remove(lt1.Back()).(*TreeNode)
    node2:=lt2.Remove(lt2.Back()).(*TreeNode)
    node1.Val+=node2.Val
    if node1.Left!=nil && node2.Left!=nil{
      lt1.PushBack(node1.Left)
      lt2.PushBack(node2.Left)
    }
    if node1.Right!=nil && node2.Right!=nil{
      lt1.PushBack(node1.Right)
      lt2.PushBack(node2.Right)
    }
    if node1.Right==nil{
      node1.Right=node2.Right
    }
    if node1.Left==nil{
      node1.Left=node2.Left
    }
  }
  return root1
}

二叉搜索树中的搜索

//700. 二叉搜索树中的搜索
func searchBST(root *TreeNode, val int) *TreeNode {
  if root==nil{
    return nil
  }
  if root.Val==val{
    return root
  }
  if root.Right!=nil{
    node:=searchBST(root.Right,val)
    if node!=nil{
      return node
    }
  }
  if root.Left!=nil{
    node:=searchBST(root.Left,val)
    if node!=nil{
      return node
    }
  }
  return nil
}

//700. 二叉搜索树中的搜索
//二叉搜索树是一个有序树：
//若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
//若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
//它的左、右子树也分别为二叉搜索树
func searchBSTV1(root *TreeNode, val int) *TreeNode {
  if root==nil || root.Val==val{
    return root
  }
  if root.Val>val{//左
    return searchBST(root.Left,val)
  }
  return searchBST(root.Right,val)
}
//700. 二叉搜索树中的搜索
func searchBSTV2(root *TreeNode, val int) *TreeNode {
  for root!=nil {
    if  root.Val==val{
      return root
    }
    if root.Val>val { //左
      root=root.Left
    }else{
      root=root.Right
    }
  }
  return nil
}