【代码随想录】Day14,15 二叉树

#二叉树的递归遍历

1. 94.  二叉树的中序遍历
2. 144. 二叉树的前序遍历
3. 145. 二叉树的后序遍历

 二叉树的前序遍历：按照访问根节点——左子树——右子树的方式遍历这棵树

1.递归

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

   preorder(root)

    return res
}

2.迭代

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

 二叉树的中序遍历：按照访问左子树——根节点——右子树的方式遍历这棵树，而在访问左子树或者右子树的时候我们按照同样的方式遍历，直到遍历完整棵树。

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

    inorder(root)
    return
}

 迭代

func inorderTraversal(root *TreeNode) []int {

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

}

二叉树的后序遍历：按照访问左子树——右子树——根节点的方式遍历这棵树，而在访问左子树或者右子树的时候，我们按照同样的方式遍历，直到遍历完整棵树。

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

    postorder(root)

    return

}

迭代

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