代码随想录算法训练营|day14

遍历方法详解

1. 递归遍历   2. 迭代遍历    3. 统一迭代

94.二叉树的中序遍历

(1)递归

func inorderTraversal(root *TreeNode) []int {
    res :=[]int{}
    inorder(root, &res)
    return res
}

func inorder(root *TreeNode, res *[]int) {
    if root == nil {
        return
    }
    inorder(root.Left, res)
    *res = append(*res, root.Val)
    inorder(root.Right, res)
}

(2)迭代

主要思路：
左子树一直压栈，直到没有子节点，记录结果，弹出，遍历右子树

func inorderTraversal(root *TreeNode) []int {
    res := []int{}
    if root == nil {
        return res
    }
    stack := []*TreeNode{}
    node := root 
    for len(stack) > 0 || node != nil {
        for node != nil {
            stack = append(stack, node)
            node = node.Left
        }
        node = stack[len(stack) - 1]
        res = append(res, node.Val)
        stack = stack[:len(stack) - 1]
        node = node.Right
    }
    return res
}

144.二叉树的前序遍历

(1)递归

func preorderTraversal(root *TreeNode) []int {
    res := []int{}
    preorder(root, &res)
    return res
}

func preorder(root *TreeNode, res *[]int) {
    if root == nil {
        return
    }
    *res = append(*res, root.Val)
    preorder(root.Left, res)
    preorder(root.Right, res)
}

(2)迭代

主要思路：
左子树压栈并记录结果，直到没有子节点，弹出，遍历右子树

func preorderTraversal(root *TreeNode) []int {
    res := []int{}
    if root == nil {
        return res
    }
    stack := []*TreeNode{}
    node := root
    for len(stack) > 0 || node != nil {
        for node != nil {
            res = append(res, node.Val)
            stack = append(stack, node)
            node = node.Left
        }
        node = stack[len(stack) - 1].Right
        stack = stack[:len(stack) - 1]
    }
    return res
}

145.二叉树的后序遍历

(1)递归

func postorderTraversal(root *TreeNode) []int {
    res := []int{}
    postorder(root, &res)
    return res
}

func postorder(root *TreeNode, res *[]int) {
    if root == nil {
        return
    }
    postorder(root.Left, res)
    postorder(root.Right, res)
   *res = append(*res, root.Val)
}

(2)迭代

主要思路：
右左子树压栈并记录结果，直到没有子节点，弹出，遍历左子树，最后反转结果

func postorderTraversal(root *TreeNode) []int {
    res := []int{}
    if root == nil {
        return res
    }
    stack := []*TreeNode{}
    node := root 
    for len(stack) > 0 || node != nil {
        for node != nil {
            res = append(res, node.Val)
            stack = append(stack, node)
            node = node.Right
        }
        node = stack[len(stack) - 1].Left
        stack = stack[:len(stack) - 1]
    }
    Reverse(res)
    return res
}

func Reverse(s interface{})  {
    sort.SliceStable(s, func(i, j int) bool {
        return true
    })
}

总结

递归和迭代都是有解题套路的！多思考问问题。