构造二叉树

使用中序+后续遍历序列构造二叉树(用一下Carl哥的图)

func buildTree(inorder []int, postorder []int) *TreeNode {
    //边界判断
    if len(inorder) == 0 {return nil}
    
    //后序的最后一个结点就是当前层逻辑root
    root := &TreeNode{postorder[len(postorder)-1], nil, nil}//root是一个指针，只能接收地址，所以这里把结构体地址传给root
    
    //递归终止条件
    if len(postorder) == 1 {
        return root
    }
    
    //找到中序遍历切片中的对应位置
    var index int 
    for i, v := range inorder {
        if  v == root.Val {
            index = i
            break
        }
    }
    
    //切割，分别切成左右子树的集合，注意各个集合的边界
    midleft := inorder[:index]
    midright := inorder[index+1:]
    postleft := postorder[:index]//注意这里index不是根，不能漏掉
    postright := postorder[index:len(postorder)-1]
    
    //递归处理，递归返回值为当前子树的根
    root.Left = buildTree(midleft, postleft)
    root.Right = buildTree(midright, postright)
    return root

}

使用前序+中序遍历序列构造二叉树

func buildTree(preOrder []int, inOrder []int)*TreeNode{
    if len(preOrder)==0 {return nil}
    root := &TreeNode{preOrder[0], nil, nil}
    if len(preOrder)==1{return root}
    index := 0
    for i,v :=range inOrder{
        if v == root.Val{index = i break}
    }
    preLeft := preOrder[1:index+1]
    preRight := preOrder[index+1:]
    inLeft := inOrder[:index]
    inRight := inOrder[index+1:]
    root.Left = buildTree(preLeft, inLeft)
    root.Right = buildTree(preRight, inRight)
    return root
}

//合并两棵二叉树，递归or层序遍历
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（root.Rigth, root2.Right)
    return root1 
}