以二叉树递归遍历为基础的题目汇总(go)

最基本的遍历递归实现

//二叉树节点数据结构定义
type TreeNode struct {
    Val int
    Left *TreeNode
    Right *TreeNode
}

前序

//递归前序，打印二叉树节点值
func preOrderTraversal(root *TreeNode) (res []int){

    var preOrder func(root *TreeNode)
    preOrder = func(root *TreeNode){
        if root == nil {
            return
        }
        res = append(res, root.Val)
        preOrder(root.Left)
        preOrder(root.Right)
    }
    preOrder(root)
    
    return
}
//迭代前序
func preOrderTraversal(root *TreeNode) (res []int){
    stack := []*TreeNode{}
    if root==nil{return}
    stack = append(stack, root.Val)
    for len(stack)!=0 {
        curNode := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        res = append(res, curNode.Val)
        if curNode.Right != nil {
            stack = append(stack, curNode.Right)
        }
        if curNode.Left != nil {
            stack = append(stack, curNode.Left)
        }
    }
    return
}

中序

//递归中序
func midOrderTraversal(root *TreeNode) (res []int){

    var midOrder(root *TreeNode)
    midOrder = func(root *TreeNode){
        if root==nil{return}
        midOrder(root.Left)
        res = append(res, root.Val)
        midOrder(root.Right)
    }
    
    midOrder(root)
    return
}
//迭代中序
func midOrderTraverse(root *TreeNode) (res []int){
    stack := []*TreeNode{}
    if root==nil{return}
    for root!=nil{
        stack = append(stack, root)
        root = root.Left
    }
    for len(stack)!=0 {
        curNode:=stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        res = append(res, curNode.Val)
        curNode = curNode.Right
        for curNode!=nil {
            stack = append(stack, curNode)
            curNode = curNode.Left
        }
    }
    return
}

后序

//后序递归
func postOrderTraverse(root *TreeNode) (res []int){
    var postOrder(root *TreeNode)
    postOrder = func(root *TreeNode){
        if root==nil {return}
        postOrder(root.Left)
        postOrder(root.Right)
        res = append(res, root.Val)
    }
    postOrder(root)
    return
}

//后续迭代，在前序迭代思路上做修改，即入栈节点先左后右，结果翻转
func postOrderTraverse(root *TreeNode) (res []int){
    stack := []*TreeNode{}
    if root == nil {return}
    stack = append(stack, root)
    
    for len(stack)!=0{
        curNode:=stack[len(stack)-1]
        stack=stack[:len(stack)-1]
        res=append(res, curNode.Val)
        if curNode.Left!=nil{
            stack=append(stack, curNode.Left)
        }
        if curNode.Right!=nil{
            stack=append(stack, curNode.Right)
        }
    }
    i, j := 0, len(res)-1
    for i<j {
        res[i], res[j] = res[j], res[i]
        i++, j--
    }
    return res
    
}

总结一下基于此的题目

二叉树最大深度，递归用后序遍历

func getMaxDepth(root *TreeNode)int{
    if root==nil {
        return 0
    }
    left := getMaxDepth(root.Left)
    right := getMaxDepth(root.Right)
    
    var max func(i, j int)int
    max = func(i, j int)int{
        if i<j {return j}
        return i
    }
    
    return max(left, right)+1   
}

n叉树最大深度

func maxDepth(root *Node) int {
    if root == nil {return 0}
    ans := 0
    for _, v := range root.Children{
        depth := maxDepth(v)
        if depth>ans{
            ans = depth
        }
    }
    return ans+1
}

二叉树最小深度

比最大深度要多考虑：左右子树为空的时候，就不能算深度了

func getMinDepth(root *TreeNode)int{
    if root == nil {return 0}
    left := getMinDepth(root.Left)
    right := getMinDepth(root.Right)
    
    if root.Left == nil && root.Right!=nil {
        return right+1
    }
    if root.Left != nil && root.Right == nil {
        return left+1 
    }
    return min(left, right)+1
}

判断是否为平衡二叉树

func isBalanced(root *TreeNode) bool {
    if root == nil {return true}
    
    //后续遍历得到长度
    var getDepth func(root *TreeNode)int
    getDepth = func(root *TreeNode)int{
        if root==nil {return 0}
        left := getDepth(root.Left)
        right := getDepth(root.Right)
        if left == -1 || right == -1 || abs(left - right)>1 {return -1}
        return max(left, right)+1
    }
    
    left := getDepth(root.Left)
    right := getDepth(root.Right)
    if left == -1 || right == -1 || abs(left - right)>1 {return false}
    return true
}

打印二叉树所有的路径总和，前序遍历

输入： root = [1,2,3,null,5]
输出： ["1->2->5","1->3"]

func binaryTreePaths(root *TreeNode)string{
    res := []string{}
    if root == nil {return res}
    
    var preOrder func(root *TreeNode, s string)
    preOrder = func(root *TreeNode, s string){
        //终止条件
        if root.Left == nil && root.Right == nil {
            v := s + strconv.Itoa(root.Val)
            res = append(v)
            return
        }
        
        s= s+strconv.Itoa(root.Val)+"->"
        if root.Left != nil {
            preOrder(root.Left, s)
        }
        if root.Right != nil {
            preOrder(root.Right, s)
        }
    }
    
    proOrder(root, "")
    return res
}